\documentstyle[11pt]{article}
\setlength{\oddsidemargin}{.125in}
\setlength{\textwidth}{6.25in}
\setlength{\textheight}{8.25in}
\setlength{\topmargin}{0in}
\renewcommand{\baselinestretch}{1.15}
\setlength{\parskip}{1ex}
\setlength{\itemsep}{1ex}
\setlength{\parindent}{5ex}
\hyphenation{Add-Data-Type data-type Data-Type Get-All-Factors
	Inv-DFTransform Inv-Z-Transform LMultiD-ROC Z-Transform}

\setcounter{page}{1}
\begin{document}
\begin{center}
{\bf
SUMMARY OF SIGNAL PROCESSING OBJECTS
}
\end{center}
\begin{enumerate}
\item {\tt \$ConvolutionDomain} (in ``Convolution.m'') \newline
	 \$ConvolutionDomain is the default domain for all of the routines  
	in the Convolution package (except for DTPiecewiseConvolution and  
	CTPiecewiseConvolution which imply a domain).  
	Use SetConvolutionDomain to reset its value. 
\item {\tt ADDITIVE} (in ``System.m'') \newline
	 ADDITIVE is a system property.  
	An operator T is additive if T[x + y] = T[x] + T[y] for all x, y.  
	It also serves as a function.  
	ADDITIVE[system] returns True if the operator system is additive.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt AKindOf} (in ``Slot.m'') \newline
	 AKindOf is a slot that describes the class to which  
	the object belongs. 
\item {\tt ASPAnalyze} (in ``ASPAnalyze.m'') \newline
	 ASPAnalyze[f, t] and ASPAnalyze[f, t, start, end]  
	will plot f(t) as a one-dimensional, continuous-time function  
	(real part shown as solid lines, imaginary part as dashed lines).  
	It will also print the strip of convergence, indicate stability  
	criteria, display the pole-zero diagram, and plot the magnitude  
	and phase responses.  
	For the two-dimensional version, t is a list of two variables  
	(like \{t1, t2\}) and start/end are optional two-element lists  
	specifying the range of the time-domain plot.  
	All non-variable symbols will be assigned a value of 1 when the  
	analyzer needs to generate a plot (override this by using options  
	like a -$>$ 2). 
\item {\tt ASSOCIATIVE} (in ``System.m'') \newline
	 ASSOCIATIVE is a system property.  
	It also serves as a function.  
	ASSOCIATIVE[system] returns True if the system is associative.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt AddChildToTree} (in ``Tree.m'') \newline
	 AddChildToTree[tree, parent, newchild] adds newchild under  
	every parent in tree. 
\item {\tt AddDataType} (in ``DataType.m'') \newline
	 AddDataType[data type], AddDataType[data type, parent data type],  
	and AddDataType[data type, parent data type, Fourier data type]  
	will update the tree data type structure to include the  
	new data type and its corresponding Fourier domain  
	data type (which defaults to Complex).  
	If data type is a symbol, a predicate will be created by  
	appending a Q to the data type.  
	For example, positive integers are a subset of integers.  
	To add this data type, use  
	AddDataType[PositiveInteger, Integer, Complex].  
	This will also defined a new query function called IsPositiveIntegerQ. 
\item {\tt AddSlot} (in ``Slot.m'') \newline
	 AddSlot[object, writeflag, slot, initvalue] adds the slot to  
	object, where object (a symbol assigned to the object's value)  
	is mutated; initvalue is the initial value assigned to this  
	new slot and writeflag is True if the slot can be overwritten.  
	The object is returned if the slot slot already exists.  
	Note that initvalue can be a collection of values like 1,2,3. 
\item {\tt AddT} (in ``TransSupport.m'') \newline
	 AddT[transq, t1, t2] adds the two transforms t1 and t2 together  
	and determines the new region of convergence.  
	The new transform is returned as a list.  
	AddT[transq, t1, t2, lowerlimit] uses lowerlimit as the lower limit  
	on region of convergence values when combining ROC's (default is 0). 
\item {\tt Aliasby} (in ``SigProc.m'') \newline
	 Aliasby[m,w][x] represents the aliasing of x, a continuous-frequency  
	signal, by replicating it every (2 Pi / m) in w and dividing the  
	result by m.  
	It is always rewritten in terms of the Periodic operator. 
\item {\tt AllDataTypes} (in ``DataType.m'') \newline
	 AllDataTypes is the universal set of all data types.  
	Symbols cannot be associated with this data type. 
\item {\tt AllSubsets} (in ``SupCode.m'') \newline
	 AllSubsets[set] returns a list of all subsets of set,  
	including the null set \{\}.  
	The original set must be a lis. 
\item {\tt Analog} (in ``FilterSupport.m'') \newline
	 Analog is continuous-time signal processing. 
\item {\tt AnalogFilter} (in ``FilterDesign.m'') \newline
	 AnalogFilter[class, time-variable, order, epsilon, A,  
	transition-ratio, cutoff-frequency] will return a filter expression  
	containing one or more of a gain term, a CFIR section, and a  
	CIIR section.  
	Here, class is one of Bessel, Butterworth, ChebyshevI, ChebyshevII,  
	Elliptic.  
	The last four arguments are filter parameters.  
	The value of the cutoff-frequency defaults to 1.  
	The Bessel filter design procedure, however, only uses the order  
	and the cutoff-frequency and ignores the other arguments.  
	See also FilterParameters and FilterOrder. 
\item {\tt AppendSlot} (in ``Slot.m'') \newline
	 AppendSlot[object, slot, appendfun, addvalue] will set the  
	value of the slot slot in object to the value returned by  
	calling appendfun with two arguments:  the old value of the  
	slot and addvalue.  
	Note that object is an unevaluated symbol and that addvalue  
	can be a collection of values like 1,2,3. 
\item {\tt Area} (in ``Convolution.m'') \newline
	 Area[ar] is an object representing the area under a Dirac delta  
	function.  
	A Dirac delta function is usually written as C Delta[t - t0],  
	where C is the area under the delta function and t0 is the location  
	of the delta function.  
	In F-interval form, C Delta[t - t0] becomes \{ Area[C], t0, t0 \}. 
\item {\tt ArraySignal} (in ``Signal.m'') \newline
	 ArraySignal[oldsig, start, end] returns a new signal which has  
	slots Start and End equal to start and end, respectively, and is  
	array-based (Implementation slot is Array). 
\item {\tt ArraySignalQ} (in ``Signal.m'') \newline
	 ArraySignalQ[signal] returns True if the signal is array-based,  
	which means that all signal values are computed at one time and  
	stored. 
\item {\tt Arrow2D} (in ``SupCode.m'') \newline
	 Arrow2D[tail, plotwidth, plotheight] returns a graphics object  
	that is an arrow starting at tail, pointing upwards, of  
	length plotheight.  
	The length of the tail can be controlled by an optional  
	fourth parameter. 
\item {\tt AssociateDataType} (in ``DataType.m'') \newline
	 AssociateDataType[symbol, datatype] will indicate to all Signal  
	Processing Packages that the symbol is of type datatype.  
	This in no way restricts assignments to that symbol.  
	For example, AssociateDataType[n, Integer] means that  
	IsIntegerQ[n] will always be True, as well as  
	IsRationalQ[n], IsRealQ[n], and IsComplexQ[n].  
	Also see DefConstant and UnAssociateDataType. 
\item {\tt AssociateItem} (in ``SupCode.m'') \newline
	 AssociateItem[item, lookuplist, newlist] finds the location of  
	item in the lookuplist and returns the element of newlist in  
	that position.  
	If item is not is lookup list, Null is returned.  
	If item is a list, then a list of associations is returned. 
\item {\tt Assuming} (in ``SupCode.m'') \newline
	 Assuming[condition] keeps track of assumptions made during  
	a calculation.  
	Assuming[All] gives all of the current assumptions.  
	Assuming[condition, True] prints the condition if it is not True.  
	Assuming[] removes all current assumptions. 
\item {\tt AutoCorrelation} (in ``Convolution.m'') \newline
	 AutoCorrelation[e, v] computes the autocorrelation of expression e  
	(in the form of a list of F-intervals, an F-interval, or a function)  
	with respect to v.  
	The variable v is treated as either discrete and continuous  
	according to the value of the Domain option.  
	The default domain is the value of \$ConvolutionDomain. 
\item {\tt Bandpass} (in ``FilterSupport.m'') \newline
	 Bandpass describes a filter that passes a band of frequencies  
	and rejects all others. 
\item {\tt Bandstop} (in ``FilterSupport.m'') \newline
	 Bandstop describes a filter that rejects a band of frequencies  
	and passes all others. 
\item {\tt Bessel} (in ``FilterSupport.m'') \newline
	 Bessel is a type of infinite impulse response (IIR) filter.  
	The step response of a lowpass Bessel function has low overshoot.  
	The transfer function is of the form d0 / Bn(s), where d0 is a  
	constant and Bn(s) is the nth-order Bessel polynomial.  
	The magnitude response of a lowpass Butterworth filter is smooth  
	(no ripples) and monotonically decreases with respect to frequency. 
\item {\tt BesselPolynomial} (in ``FilterDesign.m'') \newline
	 BesselPolynomial[order, s] results from truncating a continued  
	fraction expansion representation of the unit delay exp(-s).  
	Bessel polynomials satisfy the recursion  
	B[n, s] = (2n - 1) B[n-1, s] + s\verb:^:2 B[n-2, s], with  
	B[0, s] = 1 and B[1, s] = s + 1. 
\item {\tt BezoutNumbers} (in ``LatticeTheory.m'') \newline
	 BezoutNumbers[a, b] gives the Bezout numbers of integers a and b.  
	That is, it returns \{lambda, mu\} so that lambda a + mu b == gcd(a,b).  
	In this case, BezoutNumbers simply calls ExtendedGCD.  
	For the collection of integers a1, a2, ..., an,  
	BezoutNumbers[a1, a2, ..., an] returns a set (list) of of numbers  
	k1, k2, ..., kn such that k1 a1 + k2 a2 + ... + kn an = d,  
	where d is the greatest common divisor of a1, a2, ..., an.  
	See also ExtendedGCD. 
\item {\tt BilinearTransformation} (in ``FilterSupport.m'') \newline
	 BilinearTransformation[omega, w, k] assumes that two of three  
	arguments have value and will set the value of the unknown parameter.  
	It returns a list of the three arguments.  
	BilinearTransformation[omega, w, k, h, s, z, t] will transform  
	the analog transfer function h = f(s) into a digital transfer  
	function g(z).  
	Now, if h is instead a function of t and not of s,  
	then the Bilinear transformation will be applied to the Laplace  
	transform of h.  If h is an analog filter (see CIIR and CFIR),  
	then the result will be a digital filter (see IIR and FIR). 
\item {\tt Butterworth} (in ``FilterSupport.m'') \newline
	 Butterworth is a type of infinite impulse response (IIR) filter  
	whose magnitude squared response is of the form 1/(1 + (w/wc)\verb:^:(2 n))  
	where w is the frequency variable, wc is the cutoff frequency,  
	and n is the filter order.  
	The magnitude response of a lowpass Butterworth filter is smooth  
	(no ripples) and monotonically decreases with respect to frequency. 
\item {\tt CConvolve} (in ``SigProc.m'') \newline
	 CConvolve[t][x1, x2, ...] represents the continuous convolution in t  
	of functions x1, x2, ....  
	CConvolve[\{t1, t2, ...\}][x1, x2, ...] represents the multidimensional  
	continuous convolution in t1, t2, ... of functions x1, x2, ... 
\item {\tt CFIR} (in ``FilterSupport.m'') \newline
	 CFIR[t, \{h0, h1, h2, ...\}] represents the finite impulse response  
	of an all-zero analog filter.  
	Input to the filter is specified as FIR[t, h] [ x[t] ],  
	where x[t] is some symbolic signal processing expression.  
	For the generalized N-dimensional FIR structure,  
	the argument t becomes a list of indices (like \{t1, t2\} for N=2)  
	and the feedback coefficients are in an N x N matrix.  
	Supports option Roots, which for 1-D filters is a list of zeroes. 
\item {\tt CIIR} (in ``FilterSupport.m'') \newline
	 CIIR[t, \{a0, a1, a2, ...\}] represents an all-pole analog filter  
	with gain 1 and DC gain 1/a0.  
	The terms a1, a2, ... are the feedback coefficients.  
	The Laplace transform of such an expression is  
	1 / ( a0 + a1 s + a2 s\verb:^:2 + ... ).  
	Such filters can alternatively be specified by their poles via  
	CIIR[t, Roots -$>$ \{-1, -2, -3\}] which yields the object  
	CIIR[t, \{6., 11., 6., 1\}, Roots -$>$ \{-1, -2, -3\}].  
	CIIR is also an operator whose default input is a Dirac delta.  
	An alternate input h can be specified by  
	CIIR[t, \{a0, a1, a2, ...\}][h].  
	For the generalized N-dimensional IIR structure, the argument t  
	becomes a list of indices (like \{t1, t2\} for N=2) and the feedback  
	coefficients are specified by an N x N matrix. 
\item {\tt COMMUTATIVE} (in ``System.m'') \newline
	 COMMUTATIVE is a system property.  
	It also serves as a function.  
	COMMUTATIVE[system] returns True if the system is commutative.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt CONTINUOUS} (in ``System.m'') \newline
	 CONTINUOUS is a system property.  
	It also serves as a function.  
	CONTINUOUS[system] returns True if the operator system only takes  
	CONTINUOUS systems as arguments.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt CPulse} (in ``SigProc.m'') \newline
	 CPulse[l,t] defines a pulse which begins at t=0 and ends at t = l.  
	The CPulse has value 1 within the range (0,l),  
	0 outside this range, and 1/2 at the points t=0 and t=l.  
	A continuous-pulse center at the origin is written as  
	CPulse[l, t + l/2] or Shift[-l/2, t][CPulse[l, t]]. 
\item {\tt CStep} (in ``SigProc.m'') \newline
	 CStep[t], a.k.a. Unit[-1][t], is the unit step function  
	which is 1 for t $>$ 0, 0 for t $<$ 0, and 1/2 at t = 0.  
	It is commonly used for continuous expressions t.  
	See also Step and Unit. 
\item {\tt CTFTData} (in ``Fourier.m'') \newline
	 CTFTData is the data-tag for the CTFT. 
\item {\tt CTFTransform} (in ``Fourier.m'') \newline
	 CTFTransform[f, t] or CTFTransform[f, t, w] computes the  
	continuous-time Fourier transform of f.  
	It has time argument(s) t and frequency argument(s) w. 
\item {\tt CTPiecewiseConvolution} (in ``Convolution.m'') \newline
	 CTPiecewiseConvolution[f, g, t] carries out the one-dimensional,
	continuous-time piecewise convolution of f and g with respect to t.  
	See PiecewiseConvolution for valid representation of f and g.  
	Using F-interval notation \{function, left endpoint, right endpoint\},  
	a Dirac delta is meant when function = Area[$<$area$>$]  
	(where $<$area$>$ equals the area of under the impulse function) and  
	left endpoint = right endpoint (which is the location of the impulse). 
\item {\tt CenterOfSymmetry} (in ``Signal.m'') \newline
	 CenterOfSymmetry[signal] returns the center-of-symmetry of the  
	signal. 
\item {\tt ChebyshevI} (in ``FilterSupport.m'') \newline
	 ChebyshevI is a type of infinite impulse response (IIR) filter  
	whose magnitude squared response is of the form  
	1/(1 + e\verb:^:2 Tn(w/wc)\verb:^:2) where e controls passband ripple,  
	w is the frequency variable, and wc is the cutoff frequency.  
	The term Tn(s) is the nth-order Chebyshev polynomial.  
	The magnitude response of the stopband monotonically decreases  
	with respect to frequency. 
\item {\tt ChebyshevII} (in ``FilterSupport.m'') \newline
	 ChebyshevII is a type of infinite impulse response (IIR) filter  
	whose magnitude squared response is of the form  
	1/(1 + e\verb:^:2 Xn(w/wc)\verb:^:2) where e controls stopband ripple,  
	w is the frequency variable, and wc is the cutoff frequency.  
	Here, Xn(w) = Tn(wr) / Tn(wr / w), where Tn(w) is the nth-order  
	Chebyshev polynomial.  
	The magnitude response of the passband  
	monotonically decreases with respect to frequency. 
\item {\tt CirclePS} (in ``SupCode.m'') \newline
	 CirclePS[r] and CirclePS[r, p] will return a graphics object,  
	a circle of radius r with plotstyle p.  
	CirclePS makes use of the Circle primitive. 
\item {\tt CircularShift} (in ``SigProc.m'') \newline
	 CircularShift[n0, N, n] represents the circular shifting of a  
	sequence of length N in index variable n by n0.  
	That is, the sequence is treated as a ring buffer of length N  
	so each sample at index n is shifted to the right by
	(n + n0) mod N places.  
	See also Shift and RotateRight. 
\item {\tt ClearQueue} (in ``StackQueue.m'') \newline
	 ClearQueue[q] sets q to be an empty queue. 
\item {\tt ClearStack} (in ``StackQueue.m'') \newline
	 ClearStack[s] sets s to be an empty stack. 
\item {\tt ColumnHermiteForm} (in ``LatticeTheory.m'') \newline
	 ColumnHermiteForm[F] returns \{X, H\} where X is the m x m regular  
	unimodular matrix that puts the m x n integer matrix F into upper  
	triangular (column Hermite) form H (which is m x n).  
	That is, X . F = H. 
\item {\tt Combine} (in ``SupCode.m'') \newline
	 Combine[object, joindata] sets the value of object to the  
	joining of object with joindata; however, if object has no  
	value, then object is set to joindata. 
\item {\tt CombineDataType} (in ``DataType.m'') \newline
	 CombineDataType[ datatype1, datatype2, ...] resolves multiple  
	data types. 
\item {\tt CommutableResamplingMatricesQ} (in ``LatticeTheory.m'') \newline
	 CommutableResamplingMatricesQ[downsamplingmat, upsamplingmat]  
	returns True if the two resampling operations are commutable. 
\item {\tt ComplexAntiSymmetric} (in ``DataType.m'') \newline
	 ComplexAntiSymmetric is an abstract data type.  
	It indicates that the real and imaginary components of a  
	complex-valued sequence (or   function) are anti-symmetric.  
	See AssociateDataType. 
\item {\tt ComplexQ} (in ``SupCode.m'') \newline
	 ComplexQ[z] returns True if z is a complex number, False otherwise. 
\item {\tt ComplexSymmetric} (in ``DataType.m'') \newline
	 ComplexSymmteric is an abstract data type.  
	It indicates that the real and imaginary components of a  
	complex-valued sequence (or function) are symmetric.  
	See AssociateDataType. 
\item {\tt ComplexTo2DCoord} (in ``SupCode.m'') \newline
	 ComplexTo2DCoord[x] returns the two-dimensional coordinate  
	corresponding to the complex form of x.  
	That is, a pair of values in the form \{ Re[x], Im[x] \} is returned. 
\item {\tt ComplexTo2DCoordList} (in ``SupCode.m'') \newline
	 ComplexTo2DCoordList[zlist] returns a list of coordinates  
	corresponding to the complex form of each element in zlist.  
	That is, zlist is mapped through ComplexTo2DCoord. 
\item {\tt ComputableSignalQ} (in ``Signal.m'') \newline
	 ComputableSignalQ[signal] returns True if computational methods  
	like Fetch are supported for the signal.  
	This is true if the signal has an Implementation slot. 
\item {\tt ConjT} (in ``TransSupport.m'') \newline
	 ConjT[transq, X(s), s] implements T\{ Conj\{x(t)\} \} --$>$ X*(s*),  
	where X(s) is the transform of x(t). 
\item {\tt ConstantQ} (in ``SupCode.m'') \newline
	 ConstantQ[x] returns True if x is always constant.  
	If x is an atom, then x is constant it is a number or it x has  
	a Constant attribute.  
	If x is a function of the form f[arg1, arg2, ...], then x is  
	considered to be constant if arg1, arg2, ..., are constant. 
\item {\tt ConstantTerm} (in ``SupCode.m'') \newline
	 ConstantTerm[expr, x] returns the constant term of the  
	expression expr. 
\item {\tt Continuous} (in ``SigProc.m'') \newline
	 Continuous is a possible value for a signal's domain. 
\item {\tt ConvertFromList} (in ``Convolution.m'') \newline
	 ConvertFromList[l, t] converts a list of F-intervals in the form  
	\{f, t1, t2\} to a signal processing expression.  
	The new expression will contain either Delta, CStep, and CPulse  
	functions (continuous-time) or Impulse, Step, and Pulse functions  
	(discrete-time) according to the value of the Domain option.  
	The default domain is the value of \$ConvolutionDomain. 
\item {\tt ConvertToList} (in ``Convolution.m'') \newline
	 ConvertToList[e, t] converts the expression e to a  
	list of F-intervals in the form \{fun, left, right\}.  
	The domain of the new expression is established according to the  
	value of the Domain option.  
	The default domain is the value of \$ConvolutionDomain. 
\item {\tt Convolve} (in ``SigProc.m'') \newline
	 Convolve[n][x1, x2, ...] represents the discrete convolution in n of  
	functions x1, x2, ....  
	Convolve[\{n1, n2, ...\}][x1, x2, ...] represents the multidimensional  
	discrete convolution in n1, n2, ... of functions x1, x2, ... 
\item {\tt ConvolveT} (in ``TransSupport.m'') \newline
	 ConvolveT[transq, convop, t1, t2] implements one dimension of the   
	transform of a convolution, Convolution[All, All, t][x1, x2], where  
	convop is the convolution operator, t1 is the transform of x1,  
	and t2 is the transform of x2. 
\item {\tt CorrelationSequence} (in ``Correlation.m'') \newline
	 CorrelationSequence[x,n,z] or CorrelationSequence[X,n,z] will  
	return the correlation sequence as discrete-time function of n.  
	Note that the first argument can be either a sequence x[n] or  
	a z-transform X(z).  Also note that the last two arguments are  
	optional. 
\item {\tt DFT} (in ``SigProc.m'') \newline
	 DFT[L, n, k] is the forward discrete Fourier transform operator.  
	Here, L is the DFT length(s), n is the time-domain variable(s), and  
	k is the frequency-domain variable(s).  
	Multidimensional DFT's are supported.  
	Applying TheFunction to the DFT operator will invoke  
	the DFT rule base (object DFTransform) if loaded. 
\item {\tt DFTData} (in ``DFT.m'') \newline
	 Data-tag for the symbolic DFT. 
\item {\tt DFTransform} (in ``DFT.m'') \newline
	 DFTransform[function, NumberOfPoints, TimeVariables,  
	FourierVariables, options] returns the DFT of function,  
	where function is a function of TimeVariables defined from  
	0 to NumberOfPoints - 1.  
	Note that only the first two arguments  
	are required and that DFTransform calls DTFTransform. 
\item {\tt DISCRETE} (in ``System.m'') \newline
	 DISCRETE is a system property.  
	It also serves as a function.  
	DISCRETE[system] returns True if the system only accepts  
	DISCRETE signals as arguments.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt DSPAnalyze} (in ``DSPAnalyze.m'') \newline
	 DSPAnalyze[f, n] and DSPAnalyze[f, n, start, end]  
	will plot the real values of f[n] from n = Floor[start] to  
	n = Ceiling[end], print its z-transform, indicate conditions  
	for stability, display the pole-zero diagram, and plot the magnitude  
	and phase responses.  
	DSPAnalyze[f, \{n1,n2\}] and DSPAnalyze[f, \{n1,n2\}, \{s1,s2\}, \{e1,e2\}]  
	treat f as a function of two-variables n1 and n2.  
	The domain of the time-domain graph is n1 from s1 to e1 and  
	n2 from s2 to e2.  
	All non-variable symbols will be assigned a value of 1 when the  
	analyzer generates graphics (override this with options like a -$>$ 2). 
\item {\tt DTFT} (in ``SigProc.m'') \newline
	 DTFT[n, w] is the forward discrete-time Fourier transform operator.  
	Here, n is the time-domain variable(s), and w is the frequency-domain  
	variable(s).  
	Multidimensional DTFT's are supported.  
	Applying TheFunction to the DTFT operator will invoke the DTFT  
	rule base (object DTFTransform) if loaded. 
\item {\tt DTFTData} (in ``DTFT.m'') \newline
	 DTFTData is a data-tag. 
\item {\tt DTFTransform} (in ``DTFT.m'') \newline
	 DTFTransform[function, in variable(s), out variable(s), options]  
	returns the discrete-time Fourier transform of the input function.  
	Note that this transform may rely on the z-transform and the  
	substitution z = Exp[I w], which is not valid if the region of  
	convergence does not include the unit circle.  Also note that  
	only the first two arguments are required. 
\item {\tt DTPiecewiseConvolution} (in ``Convolution.m'') \newline
	 DTPiecewiseConvolution[f, g, n] carries out the one-dimensional,
	discrete-time piecewise convolution of f and g with respect to n.  
	See PiecewiseConvolution for the valid representations of f and g.  
	Using F-interval notation \{function, left endpoint, right endpoint\},  
	an impulse (Kronecker delta) function is meant when function = $<$value$>$  
	(where $<$value$>$ equals the strength of the impulse function) and  
	left endpoint = right endpoint (which is the location of the impulse). 
\item {\tt DataType} (in ``DataType.m'') \newline
	 DataType[expr1, expr2, ...] returns the data type which results  
	in the combination of data types in expr1, expr2, ....  
	To associate a data type with a new function aa, use  
	aa/: DataType[ aa[args ] ] := newdatatype.  
	Use AssociateDataType to associate data types with symbols.  
	Use AddDataType to add more data types to the data type rules base. 
\item {\tt DataTypeQ} (in ``DataType.m'') \newline
	 DataTypeQ[datatype1, datatype2, ...] returns True if every  
	passed data type is valid and recognized by the DataType rules base.  
	Use AddDataType to add more data types to the rules base. 
\item {\tt DataTypes} (in ``DataType.m'') \newline
	 DataTypes[] returns a listing of all recognized abstracted  
	data types.  
	DataTypes[datatype] returns a list of all symbols  
	associated with datatype.  
	DataTypes[datatype1, datatype2, ...] returns a sorted table of  
	symbols associated with the data types datatype1, datatype2, ....  
	All symbols having an associated data type can therefore be found  
	by the code fragment DataTypes[ DataTypes[] ]. 
\item {\tt DefConstant} (in ``DataType.m'') \newline
	 DefConstant[symbol] simply sets the Constant attribute of symbol.  
	DefConstant[symbol, datatype] establishes the data type of the  
	symbol as datatype by calling AssociateDataType as well as  
	setting the symbol's Constant attribute. 
\item {\tt DefaultSlot} (in ``Slot.m'') \newline
	 DefaultSlot[object tag, slot, value] will set up the value as the  
	default for the slot in any object with a tag of object tag.  
	For example, to set up 0 as the default value for the slot  
	CurrentValue of a Signal, use DefaultSlot[Signal, CurrentValue, 0]. 
\item {\tt DefineObjectType} (in ``Slot.m'') \newline
	 DefineObjectType[object, parent object] clears the attributes  
	of object and sets the HoldRest attribute. 
\item {\tt DefineSystem} (in ``System.m'') \newline
	 DefineSystem[operator, property1, property2, ...] will install  
	the operator as a system.  
	The properties property1, property2, ... are considered to be True  
	for the operator.  
	For example, if DefineSystem[Upsample[l, n], DISCRETE, LINEAR]  
	is evaluated, Upsample will be added to the list of system operators  
	SPsystems, and one of the four rules generated is  
	CONTINUOUS[Shift[l,n]] := True.  
	Note that CONTINUOUS[Shift] will have no meaning. 
\item {\tt DeleteFromTree} (in ``Tree.m'') \newline
	 DeleteFromTree[tree, node] deletes all nodes with info/name of node.  
	If the node is a parent, then the entire subtree is pruned. 
\item {\tt DeleteSlot} (in ``Slot.m'') \newline
	 DeleteSlot[object, slot] removes the slot slot from object and  
	returns the new object.  
	Note that object is an unevaluated symbol. 
\item {\tt Delta} (in ``SigProc.m'') \newline
	 Delta[expr] is the Dirac delta function.  
	The area under this functions is 1 but it only has value  
	at the origin.  
	That is, Integrate[ Delta[t] g[t], \{t, t1, t2\} ] is g[0]  
	if t1 $<$= 0 $<$= t2, 0 otherwise.  
	It differs from the Kronecker delta function Impulse[t]. 
\item {\tt DeltaIntegrate} (in ``SigProc.m'') \newline
	 DeltaIntegrate[fun, \{x, xlower, xupper\}] and DeltaIntegrate[fun, x]  
	are special hooks for the built-in Integrate routine. 
\item {\tt DeltaPlot} (in ``SigProc.m'') \newline
	 DeltaPlot is a object that can generate a plot of only Dirac delta  
	functions or a combination of Dirac delta functions and another plot.  
	In the first case, either four or six arguments are passed:  
	deltafuns, t, tmin, tmax, ymin, ymax. 
	In the second case, either five or seven arguments are passed:  
	deltafuns, t, tmin, tmax, plot, ymin, ymax.  
	In both cases, ymin and ymax are the optional arguments.  
	DeltaPlot returns a list of plots suitable for sending to Show.  
	Note that 1-D Delta functions are plotted as arrows. 
\item {\tt Dequeue} (in ``StackQueue.m'') \newline
	 Dequeue[queue, element] removes element from the queue. 
\item {\tt DerivativeT} (in ``TransSupport.m'') \newline
	 DerivativeT[transq, expr, s, m] applies the derivative operator  
	to the transform expr which is a function of s.  
	The derivative is taken m times if and only if expr satisfies transq. 
\item {\tt DesignFilter} (in ``FilterSupport.m'') \newline
	 DesignFilter[domain, class, type, time-variable, deltap,  
	deltas, w1, w2, w3, w4] returns a filter expression (involving  
	IIR/FIR or CIIR/CFIR filter sections).  
	Domain is either Analog or Digital.  
	Possibilities for class include Butterworth,  
	ChebyshevI, ChebyshevII, and Elliptic.  
	Possible filter types are Lowpass, Highpass, Bandpass, and Bandstop.  
	For lowpass filters, the magnitude response of the passband resides  
	on [1, 1 - deltap] and the magnitude response of the stopband  
	occupies [0, deltas].  
	The last two arguments, w3 and w4, are only necessary for  
	bandpass and bandstop filters.  
	Frequencies w1, w2, w3, and w4 are measured in rad/sec and  
	should be given in ascending order. 
\item {\tt DiagonalMatrixQ} (in ``LatticeTheory.m'') \newline
	 DiagonalMatrixQ[matrix] returns True if the matrix is diagonal,  
	and gives False otherwise. 
\item {\tt Dialogue} (in ``SupCode.m'') \newline
	 Dialogue is an option for all of the symbolic transforms, the  
	differential/difference equations solvers, and more.  
	Possible settings are False, True, or All, for no, partial, or  
	full justification, respectively.  
	In the case of symbolic transforms, a setting of True or All will  
	cause the rule base to describe strategies being applied to compute  
	the transform as well as the functions (if any) which it could not  
	transform.  
	If it set to All, then the rule base will also display each step  
	of the transform reasoning. 
\item {\tt Difference} (in ``SigProc.m'') \newline
	 Difference[k,n] represents the k-th backward difference with respect  
	to the variable n.  
	The first-order difference of f equals f[n] - f[n-1],  
	the second-order difference is f[n] - 2 f[n-1] + f[n-2], and so on.  
	Applying this operator to the sequence x[n] would be written as  
	Difference[k,n][ x[n] ]. 
\item {\tt Digital} (in ``FilterSupport.m'') \newline
	 Digital is discrete-time signal processing. 
\item {\tt Dirichlet} (in ``SigProc.m'') \newline
	 Dirichlet[N, w] is the aliased sinc function.  
	which is defined as Sin[N w / 2] / ( N Sin [w / 2] ).  
	Aliases for Dirichlet are ASinc, AliasSinc, and AliasedSinc. 
\item {\tt Discrete} (in ``SigProc.m'') \newline
	 Discrete is a possible value for a signal's domain. 
\item {\tt DiscreteGraphics} (in ``SigProc.m'') \newline
	 DiscreteGraphics[\{\{x1,y1\}, \{x2,y2\}, ... \{xN,yN\}\}] will plot  
	the points as lines drawn from the x-axis to the y-value.  
	It takes two optional arguments:  a line thickness and  
	a point thickness.  
	Each is a real value from 0 to 1 indicating a width that  
	is a fraction of the size of the entire graph. 
\item {\tt DiscreteTimeSignalQ} (in ``Signal.m'') \newline
	 DiscreteTimeSignalQ[signal] returns True if the signal is  
	a discrete-time signal.  
\item {\tt DistinctCosetVectors} (in ``LatticeTheory.m'') \newline
	 DistinctCosetVectors[resmat] returns a sorted list of all of the  
	distinct coset vectors associated with the resampling matrix resmat.  
	DistinctCosetVectors[resmat, U\verb:^:-1, Lambda, V\verb:^:-1] finds all of the  
	distinct coset vectors of resmat from its Smith Form  U Lambda V.  
	This is carried by finding the distinct coset vectors of the diagonal  
	matrix Lambda, mapping them by U\verb:^:-1, and then taking each vector  
	modulo the resampling matrix resmat.  
	The returned coset vectors are not sorted.  
\item {\tt Domain} (in ``SigProc.m'') \newline
	 Domain is an option for many signal processing functions.  
	It is either Discrete or Continuous. 
\item {\tt DomainScale} (in ``TransSupport.m'') \newline
	 DomainScale is an option for MagPhasePlot indicating the  
	scaling of the independent variable axis, Linear or Log,  
	for the magnitude plot. 
\item {\tt Downsample} (in ``SigProc.m'') \newline
	 Downsample[m,n] represents the downsampling operator.  
	Downsampling resamples a function at the points n = 0, m, 2m, 3m, ...  
	In N dimensions, n is a list of N indices and m is an N x N matrix.  
	Applying TheFunction to f[n] which is downsampled in one dimension,  
	(written as Downsample[m, n][ f[n] ]) will produce f[m n]. 
\item {\tt DummyVariables} (in ``SigProc.m'') \newline
	 DummyVariables[dimension, variable] generates dimension dummy  
	variables with variable as the root.  
	For example, n can be generated by DummyVariables[1, n] or  
	DummyVariables[0, n].  
	As another example, DummyVariables[3, t] returns \{t1, t2, t3\}.  
	In this cases, the generated variables have the same context  
	as variable.  
	DummyVariables[dimension, variable, context] can  
	be used to specify another context/package. 
\item {\tt Element} (in ``SupCode.m'') \newline
	 Element[expr, n] returns the nth element of expr if n is an integer  
	or list of integers.  
	Element[expr, n1, n2, ..., nm] returns expr[[n1, n2,..., nm]] if  
	n1, n2, ... nm are integers. 
\item {\tt Elliptic} (in ``FilterSupport.m'') \newline
	 Elliptic is a type of infinite impulse response (IIR) filter  
	whose magnitude squared response is of the form  
	1/(1 + e\verb:^:2 Rn(w,L)\verb:^:2) where e controls ripple, w is the frequency  
	variable, and wc is the cutoff frequency.  
	Here, Rn(w, L) is called a Chebyshev rational function  
	such that L is a parameter describing ripple properties.  
	Elliptic filters have equiripple in the passbands and stopbands. 
\item {\tt EmptyQ} (in ``SupCode.m'') \newline
	 EmptyQ[packet] returns True the packet of data is empty. 
\item {\tt EndBandwith} (in ``Signal.m'') \newline
	 EndBandwith[signal] retuns the end location of a signal's bandwidth.  
	In the case of signals that are not band-limited,  
	this function will return Infinity (the default). 
\item {\tt Enqueue} (in ``StackQueue.m'') \newline
	 Enqueue[queue, element] adds element to the queue. 
\item {\tt EuclidFactors} (in ``LatticeTheory.m'') \newline
	 EuclidFactors[k, p, q] gives the factors a and b such that  
	p a + q b == k for relatively prime p and q.  
	When p and q are integers, this routine searches over a set of  
	min($|$p$|$, $|$q$|$) integers.  
	When p and q are integer matrices, this routine searches over a  
	set of min($|$det(p)$|$, $|$det(q)$|$) integer vectors and the vector a  
	or b corresponding to the integer matrix with the smallest  
	determinant will always be a distinct coset of that matrix.  
	See also RelativelyPrime. 
\item {\tt Extent1D} (in ``SigProc.m'') \newline
	 Extent1D[expression, var] returns an interval  
	\{lower-limit, upper-limit\} outside of which the function is zero.  
	This routine assumes that var is a real variable. 
\item {\tt FIR} (in ``FilterSupport.m'') \newline
	 FIR[n, \{h0, h1, h2, ...\}] represents the finite impulse response  
	of an all-zero digital filter.  
	As a function of n, the response is actually equal to  
	h0, h1, h2, ..., for n = 0, 1, 2, ....
	Note that FIR[n, 2] will be simplified to 2 Impulse[n].  
	FIR can also represent an all-zero filter.  
	In this case, the input x[n] to the filter is specified as
	FIR[n, h] [ x[n] ], where x[n] is some symbolic  
	signal processing expression.  
	For the generalized N-dimensional FIR structure,  
	the argument n becomes a list of indices (like \{n1, n2\} for N=2)
	and the feedback coefficients are in an N x N matrix. 
\item {\tt FT} (in ``SigProc.m'') \newline
	 FT[t, w] is the forward continuous Fourier transform operator.  
	Here, t is the time-domain variable(s) and w is the  
	frequency-domain variable(s).  
	Applying TheFunction to this operator will invoke the continuous-time  
	Fourier transform rule base (object CTFTransform) if loaded. 
\item {\tt FTDataType} (in ``DataType.m'') \newline
	 FTDataType[datatype] returns the data type of datatype after  
	it has been sent through a Fourier transform. 
\item {\tt FVariables} (in ``DSupport.m'') \newline
	 FVariables is a data tag for the transform variables in a  
	Fourier transform. 
\item {\tt Fetch} (in ``Signal.m'') \newline
	 Fetch[signal, index] returns the value of the signal at index,  
	where index can be a number (for one-dimensional signals) or a  
	list of numbers (for multidimensional signals).  Fetch only  
	works for computable signals which are arrayed, pointwise, and  
	stream signals.  Stream signals also have an associated method  
	called FetchNext.  If the signal is arrayed and if any one of  
	the indices is an infinity, then the value of the signal's  
	OutOfDomainValue slot will be returned. 
\item {\tt FetchArray} (in ``Signal.m'') \newline
	 FetchArray[array signal] ... 
\item {\tt FetchNext} (in ``Signal.m'') \newline
	 FetchNext[stream signal] will return the next value in the stream  
	of data represented by stream signal. 
\item {\tt FilterOrder} (in ``FilterSupport.m'') \newline
	 FilterOrder[filter-type, transition-ratio, nu] returns the filter  
	order for the lowpass filter that meets the transition ratio  
	(for digital filters, see BilinearTransformation)  
	and the filter parameter nu (which is a function of the passband  
	and stopband ripple parameters-- c.f. FilterParameters). 
\item {\tt FilterParameters} (in ``FilterSupport.m'') \newline
	 FilterParameters[delta1, delta2, epsilon, A, Eripple, ATT, nu]  
	fills in the values of the missing parameters.  
	It assumes that either the passband ripple (delta1) and  
	the stopband ripple (delta2) or epsilon (controls ripple) and  
	A (1 / delta2) are given.  
	The values of Eripple, ATT, and nu will be computed and assigned  
	to the symbols passed into those slots.  
	Note that the passband takes on values between 1 and (1 - delta1)  
	and that the stopband takes on values between 0 and delta2.  
	The function returns a list of all seven parameters. 
\item {\tt FilterTransform} (in ``FilterDesign.m'') \newline
	 FilterTransform[filter-domain, lowpassfilter, s, new-filter-type,  
	wc, wcnew, wcnewupper] transforms a lowpass filter with  
	cutoff frequency wc into either a lowpass or highpass filter  
	with a cutoff of wcnew or a bandpass or bandstop filter with  
	lower/upper cutoff frequencies of wcnew and wcnewupper.  
	Here, the new-filter-type can be Lowpass, Highpass, Bandpass, or  
	Bandstop. 
\item {\tt FindRMinus} (in ``ROC.m'') \newline
	 FindRMinus[rminus1, rminus2] and FindRMinus[rminus1, rminus2,  
	lowerlimit] returns the greater of the two coordinates rminus1  
	and rminus2.  
	This function and FindRPlus[] are used to find  
	the intersection of two regions of convergence. 
\item {\tt FindRPlus} (in ``ROC.m'') \newline
	 FindRPlus[rplus1, rplus2] and FindRPlus[rplus1, rplus2, lowerlimit]  
	returns the lesser of the two coordinates rplus1 and rplus2.  
	This function and FindRMinus[] are used to find the intersection of  
	two regions of convergence. 
\item {\tt Finish} (in ``DFT.m'') \newline
	 Finish is a data-tag for the DFT. 
\item {\tt FourierSimplify} (in ``DSupport.m'') \newline
	 FourierSimplify[x] applies exponential to trigonometric rewrite  
	rules to expression x. 
\item {\tt GCLD} (in ``LatticeTheory.m'') \newline
	 GCLD[a, b] finds a greatest common left divisor of resampling  
	matrices a and b which is unique to within the product of  
	a regular unimodular matrix on the right.  
	It forms F = \{\{a, b\}, \{0, 0\}\} and solves the equation F . X = H  
	where X is a square regular unimodular matrix and H is the row  
	Hermite (lower-triangular) form of the rectangular matrix F.  
	Of the four submatrices of H, only H11 is non-zero.  
	The GCLD of a and b is H11.  
	This routine supports a Dialogue option.  
	See also LCLM, RowHermiteForm, and ResamplingMatrix. 
\item {\tt GCRD} (in ``LatticeTheory.m'') \newline
	 GCRD[a, b] returns a greatest common right divisor of resampling  
	matrices a and b which is unique to within the product of  
	a regular unimodular matrix on the left.  
	It forms F = \{\{a, 0\}, \{b, 0\}\} and solves the equation X . F = H  
	where X is a square regular unimodular matrix and  
	H is the column Hermite (upper-triangular) form of  
	the rectangular matrix F.  
	Of the four submatrices of H, only H11 is non-zero.  
	H11 is the GCRD.  
	This routine supports a Dialogue option.  
	See also LCRM, ColumnHermiteForm, and ResamplingMatrix. 
\item {\tt GenerateCode} (in ``SupCode.m'') \newline
	 GenerateCode[object] converts object to a string (if necessary)  
	and then evaluates it (translates it to Mathematica code). 
\item {\tt GeneratePattern} (in ``SupCode.m'') \newline
	 GeneratePattern[namestring] generates a symbol with the name  
	equal to namestring followed by an underscore, which makes the  
	object be a pattern which can be used for pattern matching.  
	For example, GeneratePattern[  a  ] yields the pattern (a ). 
\item {\tt GenerateSymbol} (in ``SupCode.m'') \newline
	 GenerateSymbol[namestring], GenerateSymbol[namestring, trailer],  
	and GenerateSymbol[namestring, trailer, header], generate a  
	symbol by concatenating header, namestring, and trailer. 
\item {\tt GetAllExponents} (in ``SupCode.m'') \newline
	 GetAllExponents[expr, x] returns all exponents of the  
	term x in the expression expr.  
	GetAllExponents[z\verb:^:3 + 2 z\verb:^:6, z] returns \{6, 3\}. 
\item {\tt GetAllFactors} (in ``SupCode.m'') \newline
	 GetAllFactors[expr, x] returns all factors of the  
	term x in the expression expr.  
	GetAllFactors[z\verb:^:3 + 2 z\verb:^:6, z] returns \{1, 2\}.  
	GetAllFactors[z\verb:^:-3 + 2 z\verb:^:-6, z] returns \{1/2, 1\}. 
\item {\tt GetAllShiftFactors} (in ``SupCode.m'') \newline
	 GetAllShiftFactors[expr, x] returns a list containing all  
	shift factors in the variable x.  
	The expression is traversed as is using a depth-first search.  
	For example, GetAllShiftFactors[ (2 s + 2 b + c) Exp[s + b + Pi], s]  
	returns \{ b + Pi, (2 b + c)/2 \}. 
\item {\tt GetArgs} (in ``SupCode.m'') \newline
	 GetArgs[function] returns the argument(s) of the function.  
	For example, GetArgs[ Bogus[1,2,3] ] would return 1,2,3.  
	If the programmer only wishes to replace the head of a function  
	with another, then use Apply instead of GetArgs.  
	This function is similar to ToCollection. 
\item {\tt GetDeltaFunctions} (in ``SigProc.m'') \newline
	 GetDeltaFunctions[function, variable(s)] will extract  
	all delta functions from the argument function.  See also DeltaPlot. 
\item {\tt GetOperatorVariables} (in ``SupCode.m'') \newline
	 GetOperatorVariables[op] returns the variable(s) in the  
	parameterized operator op.  
	By default, GetOperatorVariables[ op[par1, par2, ...] ]  
	returns the first parameter, par1. 
\item {\tt GetPosition} (in ``DataType.m'') \newline
	 GetPosition[list, element] returns the position which element  
	occurs in the list as an integer. 
\item {\tt GetRMinus} (in ``ROC.m'') \newline
	 GetRMinus returns the value of the Rminus component of the  
	region of convergence contained in the passed argument.  
	So, GetRMinus[ZTransData[x,rm,rp,z]] returns the value of rm;  
	GetRMinus[Rminus[x]] returns x; and GetRMinus[x] returns x. 
\item {\tt GetRPlus} (in ``ROC.m'') \newline
	 GetRPlus returns the value of the Rplus component of the  
	region of convergence contained in the passed argument.  
	GetRPlus[ZTransData[x,rm,rp,z]] returns the value of rp;  
	GetRPlus[Rplus[x]] returns x; and GetRPlus[x] returns x. 
\item {\tt GetRoot} (in ``SupCode.m'') \newline
	 GetRoot[rule] extracts the value from an expression like  
	\{z -$>$ 0.\}, which is 0. in this case. 
\item {\tt GetRootList} (in ``SupCode.m'') \newline
	 GetRootList[p, x] returns a list of the approximate numerical roots  
	of expression p, a function of x, with infinite roots removed.   
	GetRootList[p, x, filter] applies filter to the list of roots  
	returned by the Solve function (defaults to N).  
	When GetRootList cannot find a set of roots, it will search for  
	numeric roots. 
\item {\tt GetShiftFactor} (in ``SupCode.m'') \newline
	 GetShiftFactor[expr, x] returns a list containing the common  
	shift factor in the variable x and a normalized version of expr.  
	For example, GetShiftFactor[ (2 s + 2 b + c) Exp[s + b + Pi], s]  
	returns \{b, 2 Exp[Pi + b + s] (b + c/2 + s)\}. 
\item {\tt GetStateField} (in ``SupCode.m'') \newline
	 GetStateField[state, field] returns the value of the slot  
	field n the list state. 
\item {\tt GetValue} (in ``SupCode.m'') \newline
	 GetValue[f[n], n, n0] finds the numeric value of f[n] at n = n0  
	and GetValue[f[n1,n2], \{n1,n2\}, \{n01, n02\}] finds the numeric  
	value of f[n1,n2] at n1 = n01 and n2 = n02.  
	When the first argument has the variables embedded in it,  
	two arguments are sometimes enough:  GetValue[ object, n0 ].  
	This is true when the object is an abstract signal. 
\item {\tt GetVariables} (in ``SupCode.m'') \newline
	 GetVariables[expr] returns a list of all of the variables in  
	the expression expr.  
	See VariableQ for the definition of a variable. 
\item {\tt HOMOGENEOUS} (in ``System.m'') \newline
	 HOMOGENEOUS is a system property.  
	An operator T is homogeneous if T[a x] = a T[x] if a is a scalar.  
	It also serves as a function.  
	HOMOGENEOUS[system] returns True if the system is homogeneous.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt HasAttributes} (in ``SupCode.m'') \newline
	 HasAttributes[symbol, attribute1, attribute2, ...] returns True  
	if the evaluation of symbol is another symbol and the attributes  
	to be checked are a subset of the attributes of this other symbol.  
	HasAttributes[Plus, \{Listable, Orderless\}] would return True. 
\item {\tt HasSlotQ} (in ``Slot.m'') \newline
	 HasSlotQ[object, slot] returns True if the slot slot exists  
	in object. 
\item {\tt Highpass} (in ``FilterSupport.m'') \newline
	 Highpass describes a filter that passes all frequencies above  
	a cutoff frequency and rejects all others. 
\item {\tt IIR} (in ``FilterSupport.m'') \newline
	 IIR[n, \{a0, a1, a2, ...\}] represents the infinite impulse response  
	of an all-pole filter with gain 1, where a1, a2, ..., are the  
	negated feedback coefficients and a0 is the scaling factor of
	the output.  
	In discrete time, the output of IIR is the solution to y[n]  
	in the difference equation  a0 y[n] + a1 y[n-1] + ... + aN y[n - N] =  
	impulse[n],  with y[n] = 0 for n $<$ 0.  
	By default, the input into the filter (a.k.a. the forcing function)  
	is an impulse.  
	An alternate input h can be specified by the code  
	IIR[n, \{a0, a1, a2, ...\}][h].  
	For the generalized N-dimensional IIR structure, the argument n  
	becomes a list of indices (like \{n1, n2\} for N=2) and the feedback  
	coefficients are specified by an N x N matrix. 
\item {\tt IIRCoefficients} (in ``Signal.m'') \newline
	 IIRCoefficients is a special slot for infinite-impulse response  
	digital filters.  
	It simply contains a list of feedback coefficients. 
\item {\tt IIRFilter} (in ``Signal.m'') \newline
	 IIRFilter[p,a0,a][x] calculates the output of the IIR filter  
	at discrete time n, where the input at time n is x.  The feedback 
	coefficients are in the a vector and each is scaled by a0.  The  
	list p is a table of the last L outputs, where L is the number of  
	feedback coefficients. 
\item {\tt IIRFunction} (in ``FilterSupport.m'') \newline
	 IIRFunction[n, coeffs] and IIRFunction[n, coeffs, input] generate  
	the object IIRFunction[n, coeffs, input, TheFunction -$>$ hiir] that  
	represents a digital IIR filter with feedback coefficients coeffs  
	(see IIR for meaning) and input function input.  
	When n is an integer or real-valued integer, IIRFunction will return  
	the value of the filter computed at that sample.  
	For negative n, the value of IIRFunction is zero but the  
	value of hiir is the value of the input function (this allows  
	initial conditions to be specified in the input function).  
	Here, hiir is the actual recursive object that computes  
	values of the IIR filter only as needed.  
	To see what values have already been computed, type ??$<$hiir slot$>$. 
\item {\tt IIRPostUpdate} (in ``Signal.m'') \newline
	 IIRPostUpdate is a special method just for IIR signals. 
\item {\tt Imaginary} (in ``DataType.m'') \newline
	 Imaginary is an abstract data type.  See AssociateDataType. 
\item {\tt ImaginaryQ} (in ``SupCode.m'') \newline
	 ImaginaryQ[z] returns True if z is a number whose real part is zero. 
\item {\tt Impulse} (in ``SigProc.m'') \newline
	 Impulse[n] is the unit Kronecker Delta function.  
	At n = 0, the function evaluates to 1.  
	Elsewhere, it evaluates to 0. 
\item {\tt ImpulseTrain} (in ``LatticeTheory.m'') \newline
	 ImpulseTrain[D, n] represents an infinite collection of  
	Kronecker impulse functions.  
	In one-dimension, D and n are integers.  
	The multidimensional separable form is when both D and n are  
	integer vectors of the same length.  
	In the non-separable case, D is a resampling matrix and  
	n is an integer vector.  
	This function gives 1 whenever D\verb:^:-1 n is an integer (vector), and  
	gives 0 otherwise.  
	See also ResamplingMatrix and Impulse. 
\item {\tt InRange} (in ``SupCode.m'') \newline
	 InRange[a, b, c, amin, cmax, leftcompare, rightcompare] returns  
	True if b in between a and c.  
	The inclusiveness of the interval a to c is determined by the  
	arguments leftcompare and rightcompare, each of which defaults to  
	LessEqual.  
	So, InRange[a, b, c] returns True if a $<$= b $<$= c.  
	Non-numeric values, like Infinity, can be used for amin and cmax,  
	which default to -Infinity and +Infinity, respectively. 
\item {\tt IncList} (in ``LatticeTheory.m'') \newline
	 IncList[list, start, end] will increment the first element of list.  
	If this becomes greater than the first element of end,  
	then the next element of list will be incremented, and so forth.  
	For example, IncList[\{9,0,0\}, \{0,0,0\}, \{10,10,10\}] would return  
	\{0,1,0\} and IncList[\{9,9,9\}, \{0,0,0\}, \{10,10,10\}] would return  
	\{10,10,10\}.  
	This is useful when enumerating values over an  
	n-dimensional rectangular prism. 
\item {\tt IndependentVariable} (in ``Signal.m'') \newline
	 IndependentVariable[signal] returns the independent variable(s)  
	involved in the signal's (functional) definition. 
\item {\tt InfCheck} (in ``ROC.m'') \newline
	 InfCheck[expr] returns Infinity if expr is any Infinity form;  
	otherwise, expr is returned. 
\item {\tt InfinityQ} (in ``SupCode.m'') \newline
	 InfinityQ[a] will return True if a is Infinity, -Infinity,  
	ComplexInfinity, DirectedInfinity[], or DirectedInfinity[r]. 
\item {\tt InformUserQ} (in ``SupCode.m'') \newline
	 InformUserQ[x] returns True if the options in object x contain  
	Dialogue -$>$ All or Dialogue -$>$ True.  
	It also returns True if x is All or True. 
\item {\tt InitTree} (in ``Tree.m'') \newline
	 InitTree[root] returns an empty tree with a root of root. 
\item {\tt IntegerVectorQ} (in ``LatticeTheory.m'') \newline
	 IntegerVectorQ[arg] returns True if arg is a vector whose  
	elements are integers. 
\item {\tt IntegrateT} (in ``TransSupport.m'') \newline
	 IntegrateT[transq, t, variable, lower-limit, upper-limit] integrates  
	the transform t (with respect to variable) from lower-limit to  
	upper-limit.  
	The resulting transform is returned as a list. 
\item {\tt Interleave} (in ``SigProc.m'') \newline
	 Interleave[n][x0, x1, ...] interleaves samples of signals  
	x0, x1, ..., which are functions of n.  
	This is only applicable to discrete signals. 
\item {\tt IntersectsROC} (in ``ROC.m'') \newline
	 Intersects[rm1,rp1,rm2,rp2] returns True if the interval (rm1,rp1)  
	overlaps with the interval (rm2,rp2) in any way.  
	Therefore, IntersectsROC will return False when the two intervals  
	only overlap at endpoints. 
\item {\tt IntervalQ} (in ``Convolution.m'') \newline
	 IntervalQ[x] returns True if the argument x is an interval, and  
	gives False otherwise.  
	An interval has the form \{f, t1, t2\} such that none of f, t1, or t2  
	are lists.  
	See also ValidIntervalQ. 
\item {\tt IntervalsToFunction} (in ``SigProc.m'') \newline
	 IntervalsToFunction[interlist, n, step, pulse]  
	will translate the list of functions and intervals (interlist)  
	into a signal expression as a function of n.  
	Each element in the interlist is a list of three elements:  
	$<$function of n$>$, $<$n minus$>$, and $<$n plus$>$.  
	The function $<$function of n$>$ will be defined for  
	$<$n minus$>$ $<$= n $<$= $<$n plus$>$.  
	Note that $<$n minus$>$ can be an integer or -Infinity and  
	that $<$n plus$>$ can be an integer or Infinity.  
	The default values are n = Global`n,  
	step = Step, and pulse = Pulse.  
	This function also works for when n represents a continuous variable  
	(step = CStep and pulse = CPulse). 
\item {\tt InvCTFTransform} (in ``Fourier.m'') \newline
	 InvCTFTransform[f, w, t] computes the inverse continuous time  
	Fourier transform of f with frequency arguments w and time  
	arguments t. 
\item {\tt InvDFT} (in ``SigProc.m'') \newline
	 InvDFT[L, k, n] is the inverse discrete Fourier transform operator.  
	Here, L is the DFT length(s), n is the time-domain variable(s), and  
	k is the frequency-domain variable(s).  
	Multidimensional inverse DFT's are supported.  
	Applying TheFunction to the InvDFT operator will invoke the  
	inverse DFT rule base (object InvDFTransform) if loaded. 
\item {\tt InvDFTransform} (in ``DFT.m'') \newline
	 InvDFTransform[function, NumberOfPoints, FourierVariables,  
	TimeVariables, options] takes the inverse DFT of function,  
	where function is a function of FourierVariables defined from  
	0 to NumberOfPoints - 1.  
	Note that only the first two arguments  
	are required and that InvDFTransform calls InvDTFTransform. 
\item {\tt InvDTFT} (in ``SigProc.m'') \newline
	 InvDTFT[w, n] is the inverse discrete-time Fourier transform  
	operator.  
	Here, n is the time-domain variable(s), and w is the  
	frequency-domain variable(s).  
	Multidimensional inverse DTFT's are supported.  
	Applying TheFunction to the InvDTFT operator will invoke the  
	inverse DTFT rule base InvDTFTransform if loaded. 
\item {\tt InvDTFTransform} (in ``DTFT.m'') \newline
	 InvDTFTransform[function, in variable(s), out variable(s), options]  
	return the inverse discrete-time Fourier transform (inverse DTFT)  
	of the input function.  
	The first two arguments are required.  
	By default, the inverse DTFT rule base will apply the definition  
	of the inverse DTFT when all other attempts to find the inverse  
	have failed. 
\item {\tt InvFT} (in ``SigProc.m'') \newline
	 InvFT[w, t] is the inverse discrete Fourier transform operator.  
	Here, t is the time-domain variable(s) and w is the  
	frequency-domain variable(s).  
	Multidimensional Fourier transforms are supported.  
	Applying TheFunction to this operator will invoke the inverse  
	continuous-time Fourier transform rule base InvCTFTransform if loaded. 
\item {\tt InvL} (in ``SigProc.m'') \newline
	 InvL[s, t] is the inverse Laplace transform operator.  
	Applying TheFunction to the InvL operator will invoke the  
	bilateral inverse Laplace rule base InvLaPlace if loaded. 
\item {\tt InvLaPlace} (in ``InvLaPlace.m'') \newline
	 InvLaPlace[f, s] and InvLaPlace[f, s, t] gives the multidimensional  
	bilateral inverse Laplace transform of f.  
	A region of convergence can be specified by using  
	InvLaPlace[\{f, rm, rp\}, s, t], where rm is R- and rp is R+  
	in the region (strip) of convergence: R- $<$ Re(s) $<$ R+.  
	Note that InvLaPlaceTransform is an alias for InvLaPlace. 
\item {\tt InvZ} (in ``SigProc.m'') \newline
	 InvZ[z, n] is the inverse z-transform operator.  
	Applying TheFunction to the InvZ operator will invoke the inverse  
	z-transform rule base InvZTransform if loaded. 
\item {\tt InvZTransform} (in ``InvZTransform.m'') \newline
	 InvZTransform[e,z] or InvZTransform[e,z,n] gives the inverse  
	z-transform of e.  
	Here, e can be a function of z, a list, or a z-transform object  
	(see ZTransData).  
	As a list, e should contain three elements:  F[z], rminus, and rplus,  
	such that the region of convergence is rminus $<$ $|$z$|$ $<$ rplus.  
	If e is a z-transform object, then the inverse z-transform is simply  
	InvZTransform[e] because e contains all necessary information.  
	This routine returns signal processing expressions.  
	Convert them to mathematical formulas by using TheFunction. 
\item {\tt InvalidInvLTransformQ} (in ``LSupport.m'') \newline
	 InvalidInvLTransformQ[trans] returns True if the inverse Laplace  
	transform rule base did not successfully finish the transform. 
\item {\tt InvalidInvZTransformQ} (in ``ZSupport.m'') \newline
	 InvalidInvZTransformQ[x] returns True if the result from a  
	call to InvZTransform was not a valid inverse z-transform.  
	This occurs when the object myinvz exists in expression x. 
\item {\tt InvalidLTransformQ} (in ``LSupport.m'') \newline
	 InvalidLTransformQ[trans] returns True if the forward Laplace  
	transform rule base did not successfully finish the transform. 
\item {\tt InvalidZTransformQ} (in ``ZSupport.m'') \newline
	 InvalidZTransformQ[x] returns True if a call exists to  
	the function MyZTransform in expression x; that is, True  
	is returned if the result from a call to Z or ZTransform  
	was not a valid Z transform. 
\item {\tt Irrational} (in ``DataType.m'') \newline
	 Irrational is an abstract data type.  See AssociateDataType. 
\item {\tt IrrationalQ} (in ``DataType.m'') \newline
	 IrrationalQ[atom] returns True if the atom represents a number  
	which is irrational.  IrrationalQ[Pi] is True. 
\item {\tt IsComplexQ} (in ``DataType.m'') \newline
	 IsComplexQ[expression] returns True if the expression could  
	be considered complex-valued.  IsComplexQ[1.0] is True. 
\item {\tt IsImaginaryQ} (in ``DataType.m'') \newline
	 IsImaginaryQ[expression] returns True if the expression could  
	be considered imaginary. 
\item {\tt IsIntegerQ} (in ``DataType.m'') \newline
	 IsIntegerQ[expression] returns True if the expression could  
	be considered integer-valued. 
\item {\tt IsIrrationalQ} (in ``DataType.m'') \newline
	 IsIrrationalQ[expression] returns True if the expression could  
	be considered irrational. 
\item {\tt IsRationalQ} (in ``DataType.m'') \newline
	 IsRationalQ[expression] returns True if the expression could  
	be considered rational.  IsRationalQ[1] is True. 
\item {\tt IsRealQ} (in ``DataType.m'') \newline
	 IsRealQ[expression] returns True if the expression could  
	be considered real-valued. 
\item {\tt KVariables} (in ``DFT.m'') \newline
	 KVariables is a data-tag for the DFT. 
\item {\tt KeepNormalized} (in ``ZSupport.m'') \newline
	 KeepNormalized[zexpr, fun, z, args] keeps the z-transform  
	expression zexpr in negative powers of z after the function  
	fun is applied to zexpr and args as fun[zexpr, args]. 
\item {\tt L} (in ``SigProc.m'') \newline
	 L[t, s] is the forward Laplace transform operator.  
	Applying TheFunction to the L operator will invoke the bilateral  
	Laplace rule base if loaded. 
\item {\tt LCLM} (in ``LatticeTheory.m'') \newline
	 LCLM[a, b] returns a least common left multiple of resampling  
	matrices a and b which is unique to within the product of  
	a regular unimodular matrix on the left.  
	It forms F = \{\{a, 0\}, \{b, 0\}\} and solves the equation X . F = H  
	where X is a regular unimodular matrix and H is the column Hermite  
	(upper-triangular) form of the rectangular matrix F.  
	Of the four submatrices of H, only H11 is non-zero.  
	The LCLM of a and b is (X21 . a) = -(X22 . b).  
	This routine supports a Dialogue option.  
	See also GCRD, ColumnHermiteForm, and ResamplingMatrix. 
\item {\tt LCRM} (in ``LatticeTheory.m'') \newline
	 LCRM[a, b] finds a least common right multiple of resampling  
	matrices a and b which is unique to within the product of  
	a regular unimodular matrix on the right.  
	It forms F = \{\{a, b\}, \{0, 0\}\} and solves the equation F . X = H  
	where X is a regular unimodular matrix and H is the row Hermite  
	(lower-triangular) form of the rectangular matrix F.  
	Of the four submatrices of H, only H11 is non-zero.  
	The LCRM of a and b is (a . X12) = -(b . X22).  
	This routine supports a Dialogue option.  
	See also GCLD, RowHermiteForm, and ResamplingMatrix. 
\item {\tt LForm} (in ``LSupport.m'') \newline
	 LForm[transform] returns True if the transform is a valid  
	Laplace transform with a head of Transform or List. 
\item {\tt LINEAR} (in ``System.m'') \newline
	 LINEAR is a system property.  
	A system is linear if it is both HOMOGENEOUS and ADDITIVE.  
	It also serves as a function.  
	LINEAR[system] returns True if the operator system is linear.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt LINEARPHASE} (in ``System.m'') \newline
	 LINEARPHASE is a system property.  
	A system exhibits linear phase if the phase component of its  
	frequency response is an affine function of the frequency.  
	It also serves a a function.  
	LINEARPHASE[system] returns True if the system is memoryless.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt LMultiDROC} (in ``LSupport.m'') \newline
	 LMultiDROC[old-Laplace-transform, new-Laplace-transform]  
	combines the transform functions, regions of convergence, and  
	the transform variables in order to produce a multidimensional  
	transform. 
\item {\tt LSolve} (in ``LSolve.m'') \newline
	 LSolve[ diffequ == drivingfun, y[t] ] solves the differential  
	equation diffequ = drivingfun, where diffequ is a linear constant  
	coefficient differential equation and drivingfun is the driving  
	function (a function of t).  
	Thus, diffequ has the form a0 y[t] + a1 y'[t] + ....  
	One can specify initial values; e.g.,  
	LSolve[ y''[t] + 3/2 y'[t] + 1/2 y[t] == Exp[a t],  
	y[t], y[0] -$>$ 4, y'[0] -$>$ 10 ].  
	A differential equation of N terms needs N-1 initial conditions.  
	All unspecified conditions are considered to be zero.  
	LSolve can justify its answers. 
\item {\tt LTransData} (in ``ROC.m'') \newline
	 LTransData is a data tag for a valid Laplace transform object. 
\item {\tt LTransformQ} (in ``LSupport.m'') \newline
	 LTransformQ[x] returns True if the datum x is of the form  
	LTransData[X, rm, rp, s], where X is the LaPlace transform,  
	rm is the Rminus component of the region of convergence,  
	rp is the Rplus component of the region of convergence, and  
	s is the variable(s) in the LaPlace transform. 
\item {\tt LVariables} (in ``ROC.m'') \newline
	 LVariables is a data tag for variables in a Laplace transform object. 
\item {\tt LaPlace} (in ``LaPlace.m'') \newline
	 LaPlace[e, t] or LaPlace[e, t, s] gives the two-sided Laplace  
	transform of the expression e, which is a function of t, by  
	returning an object of four slots tagged by LTransData:  
	$<$transform$>$, $<$rminus$>$, $<$rplus$>$, $<$laplace variables$>$.  
	The Region of Convergence (ROC) is defined as  
	$<$rminus$>$ $<$ Re\{s\} $<$ $<$rplus$>$.  
	Note that the returned ROC is either the actual ROC or a subset  
	of the actual ROC.  
	In two dimensions, LaPlace[e, \{t1, t2\}, \{s1, s2\}]  
	is the same as LaPlace [ LaPlace[e, t1, s1], t2, s2 ].  
	This notation extends naturally to higher dimensions.  
	Note that the right-sided transform is specified by  
	multiplying the expression by CStep[t].  
	Also, LaPlaceTransform is an alias for LaPlace. 
\item {\tt LineImpulse} (in ``SigProc.m'') \newline
	 LineImpulse[nlist, coefflist] represents a line impulse where  
	nlist is a list of variables like \{n1,n2,n3\} and coefflist is  
	a corresponding list of coefficients like \{1,2,3\}.  
	For the previous lists, the line impulse is a set of impulse  
	along the line n1 = 2 n2 = 3 n3. 
\item {\tt LineImpulsemDT} (in ``TransSupport.m'') \newline
	 LineImpulsemDT[transq, expr, s, slist, nleft, fun] applies rules for  
	evaluating multidimensional transforms which involve line impulses,  
	like the z-transform of f[n1,n2] Impulse[n1 - n2] or the Laplace  
	transform of f[t1,t2] Delta[t1 - t2].  
	In either case, the impulse can be removed by setting n1=n2 or t1=t2,  
	which yields a one-dimensional function.  
	The resulting 1-D transform is then altered by the rule z = z1 z2  
	or s = s1 + s2, respectively.  
	Here, the argument fun is Times for the z-transform and Plus for  
	the Laplace transform.  
	Note that these rules are only applied if expr is a valid transform,  
	which occurs if transq[expr] evaluates to True. 
\item {\tt Linear} (in ``TransSupport.m'') \newline
	 Linear is a possible value for axis scaling.  See MagPhasePlot. 
\item {\tt ListQ} (in ``SupCode.m'') \newline
	 ListQ[expr] gives True if expr is a List, and False otherwise. 
\item {\tt Lowpass} (in ``FilterSupport.m'') \newline
	 Lowpass describes a filter that passes all frequencies below  
	a cutoff frequency and rejects all others. 
\item {\tt MEMORYLESS} (in ``System.m'') \newline
	 MEMORYLESS is a system property.  
	A system is memoryless if each output corresponding to a given input  
	only depends on the input (and not past values of the input).  
	It also serves a a function.  
	MEMORYLESS[system] returns True if the system is memoryless.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	A MEMORYLESS system with a single input is also SHIFTINVARIANT.  
	See also DefineSystem and SystemQ. 
\item {\tt MagPhasePlot} (in ``TransSupport.m'') \newline
	 MagPhasePlot[freqresp, \{w, wmin, wmax \}] plots the magnitude  
	and phase response over the specified range of frequencies.  
	It returns a list of two elements:  the magnitude plot and the  
	phase plot.  
	The two-dimensional version has the form  
	MagPhasePlot[freqresp, \{w1, wmin1, wmax1\}, \{w2, wmin2, wmax2\}].  
	The default options are initially biased for continuous-time  
	frequency responses of digital signals.  
	MagnitudePhasePlot is an alias for MagPhasePlot. 
\item {\tt MagRangeScale} (in ``TransSupport.m'') \newline
	 MagRangeScale is an option for MagPhasePlot indicating the  
	scaling of the dependent variable axis, Linear or Log,  
	for the magnitude plot.  
	A setting of Null disables the generation of the magnitude plot. 
\item {\tt MakeContinuousSignal} (in ``Signal.m'') \newline
	 MakeContinuousSignal[] returns a signal object with the slot  
	CONTINUOUS set to True. 
\item {\tt MakeDigitalSignal} (in ``Signal.m'') \newline
	 MakeDigitalSignal[] returns a signal object with the slot  
	DISCRETE set to True. 
\item {\tt MakeLObject} (in ``LSupport.m'') \newline
	 MakeLObject[l] and MakeLObject[l, slist] convert the LaPlace  
	transform information in list l into the standard object form  
	LTransData[x, Rminus[rm], Rplus[rp], LVariables[slist]].  
	Here x is the LaPlace transform, rm is the lower bound on the  
	strip of convergence, rp is the upper bound on the strip of  
	convergence, and slist is the list of LaPlace variables used  
	in the transform. 
\item {\tt MakeObject} (in ``Slot.m'') \newline
	 MakeObject[object] returns a packet of data tagged with object.  
	Note that an object must at most have the attribute of HoldRest.  
	See DefineObjectType. 
\item {\tt MakeSignal} (in ``Signal.m'') \newline
	 MakeSignal[] returns a signal object with one slot for system use.  
	MakeSignal[var] returns a signal object with slot  
	IndependentVariable set to var and with one slot defined for  
	system use.  
	MakeSignal[signal, n, property1, value, property2, value, ...]  
	can be used to define a signal as a function of n (the properties  
	are optional).
	If the signal is multidimensional, n will be a list of variables  
	(one for each dimension, like \{n1, n2, n3\} in the three-dimensional  
	case).  
	Possible signals include Impulse[n], Step[n], FIR[n, \{h0, h1, ...\}],
	and IIR[n, \{a0, a1, ...\}]. See MyMakeSignal. 
\item {\tt MakeZObject} (in ``ZSupport.m'') \newline
	 MakeZObject[l] and MakeZObject[l, zlist] converts the  
	z-transform information in list l into the standard object  
	form ZTransData[x, Rminus[rm], Rplus[rp], ZVariables[zlist]].  
	Here, x is the z-transform, rm is the lower bound on the  
	region of convergence, rp is the upper bound on the region  
	of convergence, and zlist is the list of z variables used in  
	the transform. 
\item {\tt MixedPolynomialQ} (in ``SupCode.m'') \newline
	 MixedPolynomialQ[p] and MixedPolynomialQ[p,x] return  
	return True if p is a polynomial in negative and positive  
	(mixed) powers of x.   
	Note that rational numbers like 5/6 and 1 are polynomials.  
	MixedPolynomialQ[x + x\verb:^:-1, x] is True. 
\item {\tt MoveOperatorsToFront} (in ``System.m'') \newline
	 MoveOperatorsToFront[head operator, signals, signals to move,  
	operator to move] will move all operator to move operators  
	contained in signals to move to the front of the expression formed  
	by the head operator operating on signals.  
	For example, MoveOperatorsToFront[ Convolve[n],  
	\{ x[n], Shift[2,n][y[n]] \}, \{ Shift[2,n][y[n]] \}, Shift ]  
	yields Shift[2,n] [ Convolve[n] [ x[n], y[n] ] ].  
	This is a valid rewriting of the original expression.  
	In this case, Convolve[n] [x[n], Shift[2,n][y[n]]].  
	This object is used in the system rewrite rules to rewrite  
	properly an operator operating on more than one signal. 
\item {\tt MultT} (in ``TransSupport.m'') \newline
	 MultT[transq, t1, t2] multiplies the transforms t1 and t2 together.  
	MultT[transq, t1, t2, lowerlimit] uses lowerlimit as the lower  
	limit on the region of convergence (ROC) when combining the ROC's of  
	t1 and t2. 
\item {\tt MultiDInvTransform} (in ``TransSupport.m'') \newline
	 MultiDInvTransform[expression, transvar, timevar, options, transq,  
	transform, makeobject, tdefault] finds the multidimensional inverse  
	transform of expression by one call to transform per dimension.  
	Here, transq, transform, and makeobject are function heads. 
\item {\tt MultiDLookup} (in ``TransSupport.m'') \newline
	 MultiDLookup[options, timevars, transformvars] expands any  
	multidimensional transform pairs into a set of one-dimensional  
	transform pairs. 
\item {\tt MultiDTransform} (in ``TransSupport.m'') \newline
	 MultiDTransform[makefun, transform, transtest, expr, expr-vars,  
	def-trans-var, trans-vars] finds the multidimensional transform  
	by calling transform once per dimension.  
	If a call to transform produces an incomplete (invalid) transform,  
	then the multidimensional transform does not exist and this routine is  
	exited.  
	The dimension of the transform is determined from  
	the number of expr-vars (which equals the number of trans-vars).  
	Here, expr is transformed. 
\item {\tt MyApart} (in ``SupCode.m'') \newline
	 MyApart[rational polynomial, x] decomposes the rational  
	polynomial into a sum of fractions whose numerators are of  
	the form (x + b)\verb:^:n where b is a constant and n is an integer.  
	MyApart uses GetRootList to find the roots and then calls Apart.  
	MyApart[rational polynomial, x, filter] specifies a filter  
	for GetRootList: Identity for rational and N for approximate roots.  
	In Mathematica 1.2, MyApart is about 25 times slower than Apart. 
\item {\tt MyCollectAll} (in ``SupCode.m'') \newline
	 MyCollectAll[ expression, var ] attempts to collect all  
	subexpressions of expression in terms of var. 
\item {\tt MyFreeQ} (in ``SupCode.m'') \newline
	 MyFreeQ[expr, form], when form is not a list, yields True if no  
	subexpression in expr matches form.  
	If form is a list, then True is returned if expr is free of  
	each element of form.  
	This is similar to MyFreeQ[expr, form1, form2, ...] which expands to  
	MyFreeQ[expr, form1] and MyFreeQ[expr, form2] and .... 
\item {\tt MyMakeSignal} (in ``Signal.m'') \newline
	 MyMakeSignal[signal, var] extends the possibilities of MakeSignal.  
	It allows the definition of standard signals as a function of var.  
	Signals defined this way include FIR[n, h0, h1, ...] and  
	IIR[n, a0, a1, ...]. 
\item {\tt MyMessage} (in ``SupCode.m'') \newline
	 MyMessage[message-label, return-value, arg1, arg2, ...] first calls  
	Message[message-label, arg1, arg2, ...] and then returns return-value. 
\item {\tt NextFun} (in ``Signal.m'') \newline
	 NextFun is a method for stream-based signals describing how to  
	compute the next value. 
\item {\tt NormalizeSamplingMatrix} (in ``LatticeTheory.m'') \newline
	 NormalizeSamplingMatrix[sampmat] will decompose the sampling matrix  
	sampmat into a diagonal matrix D and a normalized sampling matrix V.  
	The results are returned as \{ D, V \}. 
\item {\tt NullPlot} (in ``SupCode.m'') \newline
	 NullPlot is a 2-d graphics object which only contains the origin. 
\item {\tt OperatorInOperExpr} (in ``SigProc.m'') \newline
	 OperatorInOperExpr[ operator expression ] returns the full  
	operator in operator expression.  
	For example, Shift[2,n] would be returned from  
	OperatorInOperExpr[ Shift[2,n][x[n]] ]. 
\item {\tt OperatorName} (in ``SigProc.m'') \newline
	 OperatorName[ operator expression ] returns the head of the  
	expression.  
	For example, OperatorName[ Shift[2,n][x[n]] ] will return Shift. 
\item {\tt OutOfDomainValue} (in ``Signal.m'') \newline
	 OutOfDomainValue[signal] is the value to return if the signal is  
	accessed outside of its region of support.  
	This value defaults to zero. 
\item {\tt ParametersInOperExpr} (in ``SigProc.m'') \newline
	 ParametersInOperExpr[ operator expression ] returns the parameters  
	of the operator in operator expression.  
	For example, (2,n) would be returned from  
	ParametersInOperExpr[ Shift[2,n][x[n]] ]. 
\item {\tt PastValues} (in ``Signal.m'') \newline
	 PastValues is a slot that remembers previously computed signal values. 
\item {\tt PatternQ} (in ``SupCode.m'') \newline
	 PatternQ[expr] returns True if the head of expr is Pattern. 
\item {\tt Periodic} (in ``SigProc.m'') \newline
	 Periodic[k,n][f] indicates that f is a function of n which is  
	periodic with period of k. 
\item {\tt PhaseRangeScale} (in ``TransSupport.m'') \newline
	 PhaseRangeScale is an option for MagPhasePlot indicating the  
	scaling of the dependent variable axis, Linear or Log,
	for the phase plot.  
	A setting of Null disables the generation of the phase plot. 
\item {\tt PiecewiseConvolution} (in ``Convolution.m'') \newline
	 PiecewiseConvolution[f, g, v] convolves the piecewise functions  
	f and g with respect to the variable v.  
	In this context, a function is represented in a piecewise fashion:  
	(1) as F-intervals of the form \{fun, left, right\},  
	(2) as a list of F-intervals, or (3) as an expression.  
	An F-interval has the form \{function, left endpoint, right endpoint\}.  
	The F-interval notation represents a finite-extent function or  
	sequence when the endpoints do not equal infinity.  
	The result of convolution is always returned as a list of F-intervals.  
	The variable v is treated as either discrete and continuous  
	according to the value of the Domain option.  
	The default domain is the value of \$ConvolutionDomain,  
	which can be reset by SetConvolutionDomain.  
	See also CTPiecewiseConvolution and DTPiecewiseConvolution. 
\item {\tt PlotList} (in ``Convolution.m'') \newline
	 PlotList[l, \{v, vstart, vend\}] plots the piecewise function l vs. v.  
	The variable v is treated as either discrete and continuous  
	according to the value of the Domain option.  
	The default domain is the value of \$ConvolutionDomain. 
\item {\tt PointwisePlot} (in ``SupCode.m'') \newline
	 PointwisePlot[coordlist, text] and  
	PointwisePlot[coordlist, text, multiplicitytext]  
	will plot the coordinates in coordlist as text  
	for 2-D and 3-D graphics.  
	An optional fourth argument specifies the size of the font to use.  
	For multiple occurrences of the same coordinate, 
	the object multiplicitytext is displayed.  
	The last two arguments are usually symbols, numbers, or  
	FontForm objects. 
\item {\tt PointwiseSignal} (in ``Signal.m'') \newline
	 PointwiseSignal is a type of signal in which signal values are  
	computed point-by-point.  
	Such a signal does not depend on previous outputs or inputs. 
\item {\tt PointwiseSignalQ} (in ``Signal.m'') \newline
	 PointwiseSignalQ[signal] returns True if the values of the  
	signal are computed point-by-point, and the value at each  
	point is independent of other values of the signal. 
\item {\tt PoleZeroPlot} (in ``TransSupport.m'') \newline
	 PoleZeroPlot[transform-object] plots the poles and zeros of the  
	transform function as well as the region of convergence.  
	For the z-transform, this function will also plot the unit circle and  
	shade the region of convergence (whenever the ROC does not cover the  
	entire z plane).  
	To plot a transfer function f, use  
	PoleZeroPlot[f, transform-variable, rminus, rplus, zdomainflag].  
	In the two-dimensional case, the transform-variable, rminus, and  
	rplus are two-element lists.  
	The two-dimensional pole-zero plot has three cases:  
	separable transform, symmetric transform, and root map.  
	The function returns the poles of the transform. 
\item {\tt PolyphaseDownsample} (in ``SigProc.m'') \newline
	 PolyphaseDownsample[m, h, n][x] is equivalent to downsampling  
	x by m (w/r to n) and then filtering (w/r to n) by a polyphase  
	form of the FIR filter h.  
	Hence, the filtering is carried out at the lower sampling rate. 
\item {\tt PolyphaseUpsample} (in ``SigProc.m'') \newline
	 PolyphaseUpsample[l, h, n][x] is equivalent to filtering (w/r to n)  
	x by a polyphase form of the FIR filter h and then upsampling the  
	result by l (w/r to n).  
	Hence, the filtering is carried out at the lower sampling rate. 
\item {\tt Pop} (in ``StackQueue.m'') \newline
	 Pop[stack] removes and returns the value at the top of the stack. 
\item {\tt PostUpdateFunction} (in ``Signal.m'') \newline
	 PostUpdateFunction is a method which is applied to signal after  
	each computation of a new signal value. 
\item {\tt PreUpdateFunction} (in ``Signal.m'') \newline
	 PreUpdateFunction is a method which is applied to signal before  
	each computation of a new signal value. 
\item {\tt PrintIt} (in ``SupCode.m'') \newline
	 PrintIt[graphics, printer] will print out graphics on a printer.  
	If the printer is not specified, the default printer is used. 
\item {\tt PrintName} (in ``Signal.m'') \newline
	 PrintName[signal] is the name of the signal which is what is output  
	on the screen when the signal is to displayed. 
\item {\tt ProtectIt} (in ``SupCode.m'') \newline
	 ProtectIt[expr] evaluates expr.  
	If it evaluates to a symbol, that symbol will be write protected.  
	Rules can be written for that symbol,  
	but values can no longer be assigned to it. 
\item {\tt Pulse} (in ``SigProc.m'') \newline
	 Pulse[len] and Pulse[len, n] define a pulse which begins at  
	n = 0 and ends at n = len - 1.  
	A discrete pulse centered at the origin is written as  
	Pulse[len, n + (len - 1)/2] or Shift[-(len - 1)/2, n][Pulse[len, n]].  
	Sometime, a pulse will be automatically simplified;  
	e.g., Pulse[0, n] is zero and Pulse[1, n] is really Impulse[n]. 
\item {\tt Push} (in ``StackQueue.m'') \newline
	 Push[stack, element] adds the element to the top of the stack. 
\item {\tt Queue} (in ``StackQueue.m'') \newline
	 Object head for a queue structure. 
\item {\tt ROCPlot} (in ``TransSupport.m'') \newline
	 ROCPlot[\{rm, rp\}] will plot the region of convergence as a  
	shaded annular region.  
	Possible options for ROCPlot are the same as those for the  
	Show (or Plot) command. 
\item {\tt Radian} (in ``TransSupport.m'') \newline
	 Radian is a possible value for axis scaling.  See MagPhasePlot. 
\item {\tt RationalChebyshev} (in ``FilterDesign.m'') \newline
	 RationalChebyshev[n, x, xL, L] returns a rational polynomial which  
	is the nth order rational Chebyshev function evaluated at x  
	for parameters xL and L. 
\item {\tt RationalFunctionQ} (in ``SupCode.m'') \newline
	 RationalFunctionQ[f,x] returns True if expression f is of the form  
	f = g(x) / h(x), where h(x) depends on x but g(x) does not have  
	to depend on x.  
	For example, 1 / ( x + 1 ) is a rational function  
	in x but x\verb:^:3 + x\verb:^:2 + x / ( x + 1) is not. 
\item {\tt RationalGCD} (in ``SigProc.m'') \newline
	 RationalGCD[e1, e2, ...] returns the greatest common divisor of the  
	numerators of elements ei divided by the greatest common divisor of  
	the denominators of elements ei.  
	Every element must be a polynomial or a number.  
	Each real-valued and complex-valued element is rationalized  
	before GCD's are computed. 
\item {\tt RationalPolynomialQ} (in ``SupCode.m'') \newline
	 RationalPolynomialQ[p] and RationalPolynomialQ[p,x] return  
	True if p is a rational polynomial in x.  
	Note that rational numbers like 5/6 and 1 are also  
	rational polynomials. 
\item {\tt RationalQ} (in ``SupCode.m'') \newline
	 RationalQ[m] returns True if m is a rational number.  
	If m is an integer, then this function also return True,  
	since the set of integers are a subset of rationals. 
\item {\tt ReadOnlyList} (in ``Slot.m'') \newline
	 ReadOnlyList is the slot which keeps track of the slots/methods  
	which can not be altered. 
\item {\tt ReadOnlySlotQ} (in ``Slot.m'') \newline
	 ReadOnlySlotQ[object, slot or method] returns True if the  
	slot or method can not be altered in the object. 
\item {\tt ReadSlot} (in ``Slot.m'') \newline
	 ReadSlot[object, slot] returns the contents of the slot slot  
	in object.  
	Note that object is an unevaluated symbol. 
\item {\tt RealOrComplex} (in ``Signal.m'') \newline
	 RealOrComplex[signal] returns True if the signal's output values  
	are real-valued or complex-valued. 
\item {\tt RealQ} (in ``SupCode.m'') \newline
	 RealQ[z] returns True if z is a floating-point number  
	(has a head of Real), False otherwise.  See RealValuedQ. 
\item {\tt RealValuedQ} (in ``SupCode.m'') \newline
	 RealValuedQ[z] gives True if z is a number whose imaginary  
	component is 0, and gives False otherwise.  See RealQ. 
\item {\tt RegUnimodularResMatrixQ} (in ``LatticeTheory.m'') \newline
	 RegUnimodularResMatrixQ[mat] gives Ture if mat is a resampling  
	matrix with a determinant of +1 or -1, and gives False otherwise.  
	See also ResamplingMatrix. 
\item {\tt RelativelyPrime} (in ``LatticeTheory.m'') \newline
	 RelativelyPrime[a, b] returns True if a and b are relatively prime,  
	and gives False otherwise.  
	The data types of a and b must be the same.  
	Possible data types are integers, polynomials, and  
	square integer matrices (a.k.a. resampling matrices).  
	For non-diagonal resampling matrices, a third argument of  
	Right or Left is necessary to direct the matrix factorization  
	to occur on the right (using GCLD) or left (using GCRD).  
	See also GCD, PolynomialGCD, and ResamplingMatrix. 
\item {\tt RemoveOptions} (in ``SupCode.m'') \newline
	 RemoveOptions[optionlist, options] removes the options  
	from optionlist. 
\item {\tt ReorderResampling} (in ``LatticeTheory.m'') \newline
	 ReorderResampling[resmat, vars, allvars] rewrites  
	the resampling matrix resmat and the variables vars associated  
	with it so that the resampling is carried out by the order  
	of variables specified by allvars.  
	Therefore, vars must be a subset of allvars. 
\item {\tt ReplaceWith} (in ``SupCode.m'') \newline
	 ReplaceWith[oldexpr, newexpr] is a generalized way to specify  
	a substitution when the substitution may be either atomic  
	and a list of substitutions. 
\item {\tt ResamplingMatrix} (in ``LatticeTheory.m'') \newline
	 ResamplingMatrix[arg] returns True if arg is a square matrix  
	whose elements are integers and whose determinant is non-zero.  
	It returns False if arg is not a square matrix.  
	It also returns False if arg is a square matrix with one element  
	being a number that is not an integer.  
	Otherwise, it returns the conditions for which the square matrix  
	would be a resampling matrix. 
\item {\tt ResamplingMatrixMod} (in ``LatticeTheory.m'') \newline
	 ResamplingMatrixMod[n, N] implements the integer vector n  
	modulo a sampling matrix N which is defined as  
	n - N . Floor[ N\verb:^:-1 . n ].  
	The operation will be carried out if and only if n is an integer  
	vector, N is (or could be) a sampling matrix, and  
	N . n is a valid operation. 
\item {\tt Rev} (in ``SigProc.m'') \newline
	 Rev[n][x] represents the operation of reversing the direction of x,  
	with respect to the variables(s) n. 
\item {\tt RewriteSummations} (in ``SigProc.m'') \newline
	 RewriteSummations[f, t, tlower, tupper] rewrites Summation  
	and Periodic operators that appear in f so that the domain  
	of the new expression includes t in [tlower, tupper].  
	It relies on the Extent1D function to compute the domain  
	of the arguments to the Periodic and Summation operators. 
\item {\tt RightSided} (in ``ZSolve.m'') \newline
	 RightSided is an option for ZSolve.  
	If True, then the solution to the difference equation will be  
	right-sided, left-sided otherwise. 
\item {\tt Rminus} (in ``ROC.m'') \newline
	 Rminus[ $<$r-minus$>$ ] is the head for the R- value in a transform. 
\item {\tt RootLocus} (in ``TransSupport.m'') \newline
	 RootLocus[f(z), z, \{freeparam, start, end, step\}] plots  
	the root locus of f(z) with respect to freeparam over the  
	range of start to end at increments of step.  
	In order to connect the points, the function f(z) will be factored  
	symbolically with respect to z.  
	All closed-form factors of reasonable size will be graphed as  
	parametric plots.  
	RootLocus will generate three plots:  the pole zero plot for  
	freeparam = start, the root locus, and the pole-zero plot for  
	freeparam = end.  
	The function returns a list of all three plots.  
	RootLocus supports the same options as does Show.  
	RootLocusPlot is an alias of RootLocus. 
\item {\tt RowHermiteForm} (in ``LatticeTheory.m'') \newline
	 RowHermiteForm[F] returns \{X, H\} where X is the n x n regular  
	unimodular matrix that puts the m x n integer matrix F into  
	lower triangular (row Hermite) form H (which is m x n).  
	That is, F . X = H. 
\item {\tt Rplus} (in ``ROC.m'') \newline
	 Rplus[ $<$r-plus$>$ ] is the head for the R+ value in a transform. 
\item {\tt RuleAppliesQ} (in ``SupCode.m'') \newline
	 RuleAppliesQ[expr, rule] returns True if rule applies to expr.  
	RuleAppliesQ[head[expr1, expr2, ..., exprn], rule, head] returns  
	True if the rule applies to each expression expr1, expr2, ...,  
	exprn. 
\item {\tt SEPARABLE} (in ``System.m'') \newline
	 SEPARABLE is a system property.  
	It describes multidimensional systems that can decomposed  
	into a cascade of one-dimensional operations.  
	It also serves as a function.  
	SEPARABLE[system] returns True if the  
	operator system is separable.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt SHIFTINVARIANT} (in ``System.m'') \newline
	 SHIFTINVARIANT is a system property.  
	It means that a shift in the input causes the same shift  
	in the output.  
	It also serves as a function.  
	SHIFTINVARIANT[system] returns True if the  
	operator system is shift-invariant.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt SPHeuristicRewrite} (in ``Heuristics.m'') \newline
	 SPHeuristicRewrite[expr, rules] tries to rewrite expressions  
	on the same level of expr together using the list of rules. 
\item {\tt SPLessGreaterRules} (in ``SupCode.m'') \newline
	 SPLessGreaterRules are a collection of rules for simplifying  
	expressions involving inequalities. 
\item {\tt SPRecursiveRewrite} (in ``Heuristics.m'') \newline
	 SPRecursiveRewrite[expr, rules] only returns a fully rewritten  
	version of the signal processing expression expr.  
	The Rewrite knowledge base is let loose on the expression expr  
	without any guidance.  
	The user can see the intermediate expressions by setting the  
	Dialogue option to True or False. 
\item {\tt SPRecursiveRewrite} (in ``RewriteRules.m'') \newline
	 SPRecursiveRewrite[expr] only returns a fully rewritten version of  
	the signal processing expression expr.  
	The Rewrite knowledge base is let loose on the expression expr  
	without any guidance.  
	The user can see the intermediate expressions by setting the  
	Dialogue option to True or False. 
\item {\tt SPSimplificationRules} (in ``SupCode.m'') \newline
	 SPSimplificationRules are a collection of simplification rules  
	that are not carried out by Simplify.  
	These rules require too much overhead to encode them directly  
	into Mathematica.  
	See also SPSimplify. 
\item {\tt SPSimplify} (in ``SigProc.m'') \newline
	 SPSimplify[e] will simplify expression e according to Mathematica's  
	simplification rules and the rules in SPSimplificationRules.  
	At each iteration, Simplify is called and SPSimplificationRules  
	is applied to the result.  
	Unlike Simplify, SPSimplify supports a Dialogue option.  
	You can specify which symbols to treat as real variables by using  
	the Variables option. 
\item {\tt SPfunctions} (in ``SupCode.m'') \newline
	 SPfunctions maintains a current list of those new routines  
	that have been loaded from the signal processing packages. 
\item {\tt SPoperators} (in ``SupCode.m'') \newline
	 SPoperators maintains a current list of the new mathematical  
	operators that have been loaded from the signal processing packages. 
\item {\tt SPproperties} (in ``System.m'') \newline
	 SPproperties contains a list of currently recognized  
	system properties like LINEAR. 
\item {\tt SPsignals} (in ``SupCode.m'') \newline
	 SPsignals maintains a current list of those new signals  
	(mathematical functions) that have been loaded from the  
	signal processing packages. 
\item {\tt SPsystems} (in ``System.m'') \newline
	 SPsystems is a list of all recognized systems.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	New ones can be defined by using DefineSystem. 
\item {\tt SameFormQ} (in ``SupCode.m'') \newline
	 SameFormQ[pattern, expr1, expr2, ...] returns True if every  
	expression matches pattern via MatchQ.  
	Once an expression does not match,  
	this function immediately returns False. 
\item {\tt ScaleAxis} (in ``SigProc.m'') \newline
	 ScaleAxis[l,w][x] represents the compression by a factor of l (an  
	integer) of the continuous w axis of x, which is usually a  
	continuous-frequency signal. 
\item {\tt ScaleT} (in ``TransSupport.m'') \newline
	 ScaleT[transq, t, c] multiplies the transform t by c while leaving  
	the region of convergence unaltered.  
	The resulting transform is returned as a list. 
\item {\tt ScalingFactor} (in ``SigProc.m'') \newline
	 ScalingFactor[expr, variable] returns the greatest common divisor  
	of all coefficients of powers of z in expr.  
	The powers of z that are functions of z are not considered.  
	For example, ScalingFactor[ a z + a\verb:^:2 z\verb:^:2, z ] returns a.  
	This function enables the implementation of the similarity  
	property for transforms. 
\item {\tt Second} (in ``SupCode.m'') \newline
	 Second[list] returns the second element of list. 
\item {\tt Self} (in ``Signal.m'') \newline
	 Self is a pre-defined slot that is bound to the entire object  
	of which it is a member.  
	It can be used as a variable in methods and slots. 
\item {\tt SequencePlot} (in ``SigProc.m'') \newline
	 SequencePlot[f, \{n, start, end\}] plots real-valued 1-D sequences  
	and has the same options as Show.  
	You will have to apply Re or Im to f to plot the real or  
	imaginary values of the sequence, respectively.  
	SequencePlot[f, \{n1, start1, end1\}, \{n2, start2, end2\}] plots  
	2-D sequences and supports the same options as Plot3D. 
\item {\tt SequenceToFunction} (in ``SigProc.m'') \newline
	 SequenceToFunction[seq], SequenceToFunction[seq, n], and  
	SequenceToFunction[seq, n, noffset] return the sequence seq,  
	\{x[noffset], ..., x[noffset + N - 1]\}, in symbolic form as a sum of  
	impulse functions.  
	For example, SequenceToFunction[\{1, 2, 3\}] -$>$  
	Impulse[n] + 2 Impulse[n - 1] + 3 Impulse[n - 2].  
	For multidimensional sequences, the argument n must be a list of  
	variables of appropriate length.  
	For example, SequenceToFunction[\{\{1,2\},\{3,4\}\}, \{n1, n2\}] -$>$  
	Impulse[n1,n2] + 2 Impulse[n1,n2-1] + 3 Impulse[n1-1,n2] +  
	4 Impulse[n1-1, n2-2]. 
\item {\tt SetConvolutionDomain} (in ``Convolution.m'') \newline
	 SetConvolutionDomain[domain] establishes the default convolution  
	domain as either Continuous or Discrete.  
	It returns domain on success, and Null on error. 
\item {\tt SetExclusion} (in ``SupCode.m'') \newline
	 SetExclusion[set1, set2, ...] returns a set equal to the union  
	of the sets minus the intersection of the sets. 
\item {\tt SetStateField} (in ``SupCode.m'') \newline
	 SetStateField[state, field, value] will return a new state,  
	which is a copy of the list state except that the value of  
	the slot field will be equal to value. 
\item {\tt ShadedAnnulus} (in ``TransSupport.m'') \newline
	 ShadedAnnulus[rm, rp] and ShadedAnnulus[rm, rp, angulartilt]  
	will create a 2-D graphics object that is an annulus  
	(rm $<$ radius $<$ rp) filled with uniformly spaced horizontal  
	lines rotated by angulartilt degrees. 
\item {\tt Shift} (in ``SigProc.m'') \newline
	 Shift[m,v][x] represents the shifting of the expression x by m  
	samples to the right in the v direction, i.e. x[v] --$>$ x[v - m]. 
\item {\tt Signal} (in ``Signal.m'') \newline
	 A signal is an object with head Signal.  
	From the work of Cory Myers, possible slots include:  
	Bandwidth, CenterOfSymmetry, End, EndBandwidth, Period, Start,  
	StartBandwidth, Support, and Symmetry.  
	Possible additional slots are:  
	CurrentValue, DataType, Dimensions, FrequencyVariables,  
	Implementation, Length, OutOfDomainValue, TheFunction,  
	TimeVariables, ZTransData, ZVariables, CurrentIndex,  
	NextFun, PreUpdateFunction, and PostUpdateFunction.  
	Multidimensional signals are supported.  See MakeSignal. 
\item {\tt SignalCleanup} (in ``SigProc.m'') \newline
	 SignalCleanup[ expr, t, nstart, nend ] converts the signal  
	expression expr in variables t into a normal Mathematica expression  
	that can be plotted over the interval [nstart, nend].  
	It returns a list of two expressions:  the first consists of the
	Delta functions extracted from expr, and the second is the rest
	of the expression. 
\item {\tt SignalPlot} (in ``SigProc.m'') \newline
	 SignalPlot[f, \{t, start, end\}] will plot f(t) as an one-dimensional,  
	continuous-time function.  
	It will show the real part as solid lines,  
	and the imaginary part as dashed lines.  
	Delta functions are plotted as upward pointing arrows.  
	SignalPlot[f, \{t1, start1, end1\}, \{t2, start2, end2\}] treats f  
	as a function of two variables t1 and t2.  
	SignalPlot supports the same options as Plot for 1-D signals  
	(functions) and Plot3D for 2-D signals (functions). 
\item {\tt SignalQ} (in ``Signal.m'') \newline
	 SignalQ[x] returns True if the head of x is Signal. 
\item {\tt SignalsInOperExpr} (in ``SigProc.m'') \newline
	 SignalsInOperExpr[ operator expression ] returns the signal(s)  
	of the operator in operator expression.  
	For example, \{ x[n] \} would be returned from  
	SignalsInOperExpr[ Shift[2,n][x[n]] ].  
	Another version SignalsInOperExpr[ operator expression, operator ]  
	behaves as the first version if operator is the head of  
	operator expression; otherwise, operator expression is returned. 
\item {\tt SimplifyList} (in ``Convolution.m'') \newline
	 SimplifyList[interval list, v] takes a list of F-intervals  
	each having the form \{f, t1, t2\} and returns a simplified sorted  
	list of F-intervals.  
	The interval list is treated as either a continuous-time or a  
	discrete-time function according the value of the Domain option.  
	The variable v is treated as either discrete and continuous  
	according to the value of the Domain option.  
	The default domain is the value of \$ConvolutionDomain. 
\item {\tt Sinc} (in ``SigProc.m'') \newline
	 Sinc[t] is the unit sinc function which is the ratio of  
	Sin[t] over t.  Note that Sinc[0] = 1. 
\item {\tt SmithFormSameU} (in ``LatticeTheory.m'') \newline
	 SmithFormSameU[smithfun, m1, m2] computes the Smith Form of the  
	integer matrix m1 so that m1 = u1 d1 v1.  
	The routine then uses u2 = u1 to decompose m2.  
	The first argument specifies which decomposition routine should  
	be used to decompose m1 (e.g., SmithNormalForm).  
	The routine returns \{cond, \{u1\verb:^:-1, d1, v1\verb:^:-1\}, \{u2\verb:^:-1, d2, v2\verb:^:-1\}\},  
	where cond is True of False depending on whether or not matrices  
	m1 and m2 can be decomposed using the same U. 
\item {\tt SmithFormSameV} (in ``LatticeTheory.m'') \newline
	 SmithFormSameV[smithfun, m1, m2] computes the Smith Form of the  
	integer matrix m1 so that m1 = u1 d1 v1.  
	The routine then uses v2 = v1 to decompose m2.  
	The first argument specifies which decomposition routine should  
	be used to decompose m1 (e.g., SmithNormalForm).  
	The routine returns \{cond, \{u1\verb:^:-1, d1, v1\verb:^:-1\}, \{u2\verb:^:-1, d2, v2\verb:^:-1\}\},  
	where cond is True of False depending on whether or not matrices  
	m1 and m2 can be decomposed using the same V. 
\item {\tt SmithNormalForm} (in ``LatticeTheory.m'') \newline
	 SmithNormalForm[A] returns a list of three matrices  
	U\verb:^:-1, D, and V\verb:^:-1 such that the m x n resampling matrix A  
	equals U D V where U (m x m) and V (n x n) are integer matrices  
	with determinants of +1 or -1 and D is a diagonal matrix  
	of integer components such that $|$det(D)$|$ = $|$det(A)$|$.  
	The algorithm follows Kaufmann's \{Integer and Mixed Programming\}.  
	Note that this factorization is not unique.  
	SmithNormalForm supports a Dialogue option.  
	If Dialogue is True or All, SmithNormalForm will show immediate steps.  
	See also SmithOrderedForm and SmithReducedForm. 
\item {\tt SmithOrderedForm} (in ``LatticeTheory.m'') \newline
	 SmithOrderedForm[A] returns a list of three matrices  
	U, D, and V such that the m x n resampling matrix A  
	equals U D V where U (m x m) and V (n x n) are integer matrices  
	with a determinant of 1 and D is a diagonal matrix  
	of integer components such that det(D) = det(A).  
	The components along the diagonal of D are sorted by absolute value.  
        The diagonal elements are positive except for possibly the  
	last one whose sign will be the sign of det(A).  
	Note that this factorization is unique if none of the diagonal  
	elements are equal in absolute value.  
	Also note that the starting point is the result of the Smith  
	Normal Form decomposition.  
	Like SmithNormalForm, SmithOrderedForm supports a Dialogue option.  
	If True or All, SmithNormalForm will show immediate steps.  
	See also SmithNormalForm and SmithReducedForm. 
\item {\tt SmithReducedForm} (in ``LatticeTheory.m'') \newline
	 SmithReducedForm[A] returns a list of three matrices  
	U, D, and V such that the m x n resampling matrix A  
	equals U D V where U (m x m) and V (n x n) are integer matrices  
	with a determinant of +1 or -1 and D is a diagonal matrix  
	of positive integers such that $|$det(D)$|$ = $|$det(A)$|$.  
	Each component down the diagonal is a factor of the next one.  
	As a result, the diagonal elements are sorted down the diagonal.  
	The factorization is not unique.  
	Note that the starting point for this algorithm is the Smith  
	Ordered Form.  
	Like SmithOrderedForm, SmithReducedForm supports a Dialogue option.  
	If True or All, SmithNormalForm will show immediate steps.  
	See also SmithNormalForm and SmithOrderedForm. 
\item {\tt Stable} (in ``TransSupport.m'') \newline
	 Stable[transexpr] returns True if the transform transexpr  
	represents a stable time-domain signal. 
\item {\tt Start} (in ``DFT.m'') \newline
	 Start is a data-tag for the DFT. 
\item {\tt StartBandwith} (in ``Signal.m'') \newline
	 StartBandwith[signal] returns the starting location of the bandwidth  
	of the signal.  
	For signals that are not bandlimited,  
	this method will return -Infinity which is the default value. 
\item {\tt Step} (in ``SigProc.m'') \newline
	 Step[n] is the unit step function which is 1 for n $>$= 0  
	and 0 otherwise.  
	It is commonly used for discrete n.  
	This function differs from CStep only at the origin. 
\item {\tt StreamSignal} (in ``Signal.m'') \newline
	 StreamSignal is a type of signal that computes its outputs one
	after another usually without reference to past values. 
\item {\tt StreamSignalQ} (in ``Signal.m'') \newline
	 StreamSignalQ[signal] returns True if the values of signal are  
	computed one at a time in some order.  
	The value at each point can be dependent on previously-computed  
	values, state information, etc.  
	Signals generated by finite state machines are stream signals. 
\item {\tt StripPackage} (in ``SupCode.m'') \newline
	 StripPackage[symbol] returns the symbol (as a string) after its  
	context has been removed.  
	To remove the package definition from every symbol in expression,  
	use MapAll[StripPackaage, expression]. 
\item {\tt SubDataTypeQ} (in ``DataType.m'') \newline
	 SubDataTypeQ[expression, datatype] returns True if the data type  
	of expression could be coerced to datatype.  
	For example, SubDataTypeQ[5, Rational] is True, but  
	SubDataTypeQ[5.0, Rational] is False. 
\item {\tt SubT} (in ``TransSupport.m'') \newline
	 SubT[transq, t1, t2] subtracts the transforms t2 from t1 and  
	determines the new region of convergence.  
	The resulting transform is returned as a list.  
	SubT[transq, t1, t2, lowerlimit] uses lowerlimit as the lower limit  
	on region of convergence values when combining ROC's (default is 0). 
\item {\tt SubTree} (in ``Tree.m'') \newline
	 SubTree[tree, head] returns the subtree with root head. 
\item {\tt SubsetQ} (in ``SupCode.m'') \newline
	 SubsetQ[set1, set2, set3,  ...] returns True if set1 is a subset  
	of set2 and set2 is a subset of set3, etc. 
\item {\tt SubstituteForT} (in ``TransSupport.m'') \newline
	 SubstituteForT[transq, t, s, news] substitutes news at every  
	occurrence of s in the transform t.  
	The resulting transform is returned as a list. 
\item {\tt Summation} (in ``SigProc.m'') \newline
	 Summation[i][f], Summation[i, iend][f], and  
	Summation[i, istart, iend, inc][f] represents the summation of f  
	with respect to variable i:  i = (istart) to (iend) step (inc).  
	The Summation operator is an abstraction of Mathematica's Sum object.  
	Applying the object TheFunction to a Summation operator will invoke  
	the Sum object if istart, iend, and inc are numbers. 
\item {\tt SymbolDataType} (in ``DataType.m'') \newline
	 SymbolDataType[symbol] returns the data type associated with  
	symbol or AllDataTypes if none exists. 
\item {\tt SymbolDataTypeQ} (in ``DataType.m'') \newline
	 SymbolDataTypeQ[symbol, data-type] returns True if the symbol  
	is associated with the data type data-type.  
	Note that if a symbol is associated with Real,  
	then it is also associated with Integer and Rational as well. 
\item {\tt SystemProperties} (in ``System.m'') \newline
	 SystemProperties[system] will show the properties attached to  
	of an operator or list of operators.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	See also DefineSystem and SystemQ. 
\item {\tt SystemQ} (in ``System.m'') \newline
	 SystemQ[system] will give True if system is in the SPsystems list,  
	and False otherwise.  
	Note that a system is a (parameterized) operator to which  
	DefineSystem has attached properties.  
	For example, by default, Shift[L, n] has been installed as a system,  
	but Shift without the parameters has not. 
\item {\tt SystemRewriteRules} (in ``RewriteRules.m'') \newline
	 SystemRewriteRules contains a list of over 50 rewrite rules for  
	operators (systems) .  
	This rule is composed of three other rule bases:  
	(1) rules based on operator properties,  
	(2) rules for single rate digital signal processing, and  
	(3) rules for multirate digital signal processing.  
	The rules in (1) are patterned after those found in Myers' Signal  
	Processing Language and Interactive Computing Environment (SPLICE)  
	and Covell's Algorithm Design Environment (ADE). 
\item {\tt TableLookup} (in ``SupCode.m'') \newline
	 TableLookup[index, hlist, len, val] returns hlist[[index]]  
	if index is between 1 and len, inclusive; otherwise, val is  
	returned. 
\item {\tt TheFunction} (in ``SigProc.m'') \newline
	 TheFunction[object] returns the mathematical function embedded  
	in object.  
	For list and transform objects, this function returns  
	the first element after the head of the object; otherwise, the  
	contents of the slot TheFunction are returned.  
	For signal processing operations,  
	the equivalent mathematical operation is returned. 
\item {\tt Third} (in ``SupCode.m'') \newline
	 Third[list] returns the third element of list. 
\item {\tt ToCollection} (in ``SupCode.m'') \newline
	 ToCollection[expr] strips the head off of arg and returns  
	the argument of expr as a collection.  
	ToCollection returns an object that is a sequence,  
	which is represented in Mathematica 1.2 as (a1, a2, ...)  
	and in Mathematica 2.0 as Sequence[a1, a2, ...].  
	So, it provides a unified way of generating collections (sequences). 
\item {\tt ToContinuous} (in ``SigProc.m'') \newline
	 ToContinuous[expr] replaces any discrete operator or signal  
	in expr with its continuous equivalent. 
\item {\tt ToDiscrete} (in ``SigProc.m'') \newline
	 ToDiscrete[expr] replaces any continuous operator or signal  
	in expr with its discrete equivalent. 
\item {\tt ToList} (in ``SupCode.m'') \newline
	 ToList[arg] returns arg if arg is a list.  
	Otherwise, List[arg] is returned.  
	ToList[arg1, arg2, ...] returns List[arg1, arg2, ...]. 
\item {\tt TopElement} (in ``StackQueue.m'') \newline
	 TopElement[packet] returns the first element in the data packet.  
	This is the top of the stack if packet is a stack.  
	This is the next in the queue if packet is a queue.  
	The packet remains unaltered. 
\item {\tt Transform} (in ``ROC.m'') \newline
	 Transform[transform, rminus, rplus] represents a transform.  
	Transform is also a tag for exporting errors messages like  
	Transform::twosided.  
	This object is used exclusively by the  
	various transform rule bases. 
\item {\tt TransformDialogue} (in ``TransSupport.m'') \newline
	 TransformDialogue[ strategy, options, arg1, arg2, ... ] is the  
	routine that displays textual dialogue about the strategy being used  
	by a particular transform. 
\item {\tt TransformFixUp} (in ``TransSupport.m'') \newline
	 TransformFixUp[time var, transform var, options,  
	transform head, triplet flag, transform name, lower, upper]  
	attempts to resolve incomplete transforms according to the  
	transform pairs provided by the user via the TransformLookup option.  
	If the transform is a triplet of information (funct, Rminus, Rplus),  
	e.g. the forward z- and Laplace transforms, then triplet flag is True  
	and the lower and upper arguments are used for the second and  
	third fields of the triplet. 
\item {\tt TransformLookup} (in ``TransSupport.m'') \newline
	 TransformLookup is an option for the transform rule bases.  
	It allows the user to specify a list of transform pairs to augment  
	those that already exist in the transform rule bases.  
	For example, ZTransform[ Shift[L, n][x[n]], n, z,  
	TransformLookup -$>$ \{ x[n] :$>$ X[z] \} ].  
	To specify a region of convergence, use  
	TransformLookup -$>$ \{ x[n] :$>$ \{ X[z], rm, rp \} \}.  
	This example allows the user to work x[n] without every defining it.  
	The multidimensional case is more tricky:  
	ZTransform[ x[n1, n2], n, z, TransformLookup -$>$  
	\{ x[n1, n2] :$>$ X[z1, n2], X[z1, n2] :$>$ X[z1, z2] \} ].  
	A region of convergence can be specified for each dimension.  
	For the z- and Laplace transform rule bases, one can also specify  
	a region of convergence associated with the transform pairs. 
\item {\tt UnAssociateDataType} (in ``DataType.m'') \newline
	 UnAssociateDataType[symbol] removes any association of that  
	that symbol with any data type.  
	UnAssociateDataType[symbol, datatype] removes the association  
	of symbol with datatype if one exists.  
	The function returns symbol.  
	See also AssociateDataType. 
\item {\tt Unit} (in ``SigProc.m'') \newline
	 Unit[n][t] is the nth order continuous unit function in t.  
	Unit[0][t] is the Dirac delta function (see Delta).  
	Unit[-1][t] is the continuous step function (see CStep). 
\item {\tt UnprotectIt} (in ``SupCode.m'') \newline
	 UnprotectIt[expr] evaluates expr.  
	If it evaluates to a symbol,  
	write protection will be removed for that symbol. 
\item {\tt Upsample} (in ``SigProc.m'') \newline
	 Upsample[k,n][f] represents the upsampling operation on f,  
	which is either an expression of n or a sequence (list) of values.  
	Upsampling inserts k-1 zeroes between every two samples.  
	In N dimensions, n is a list of N indices and k is an N x N matrix. 
\item {\tt UpsampleFactor} (in ``SigProc.m'') \newline
	 UpsampleFactor[f, n] returns the upsampling index which can be  
	a negative or positive number.  
	If this routine returns 1 or -1, then no upsampling has occurred;  
	if it returns 0, then f is constant with respect to n. 
\item {\tt UpsampleSequence} (in ``SigProc.m'') \newline
	 UpsampleSequence[seq,m,fill] inserts m-1 fill values between  
	every two elements of seq. 
\item {\tt UpsampledFunction} (in ``SigProc.m'') \newline
	 UpsampledFunction[m, fill, n, upf] represents the upsampling of f.  
	In one-dimension, the upsampled form of f, upf,  
	is obtained by evaluating n -$>$ n / m. 
\item {\tt UpsampledSystem} (in ``LatticeTheory.m'') \newline
	 UpsampledSystem[expr, vars] returns a resampling matrix and  
	a set of linearly coupled variables taken from the master list vars.  
	For example, UpsampledSystem[Cos[w1 + w2] Sin[w1 - w2], \{w1, w2\} ]  
	will return \{ \{\{1,1\},\{1,-1\}\}, \{w1,w2\} \}.  
	In this case, the dot product of the resampling matrix and the  
	variable list give \{w1 + w2, w1 - w2\}.  
	A third optional argument would be a function to extract coefficients  
	that takes an expression, a list of variables, and a value to return  
	on failure. 
\item {\tt ValidIntervalQ} (in ``Convolution.m'') \newline
	 ValidIntervalQ[i] returns True if i is a valid F-interval, and  
	gives False otherwise.  
	An F-interval is an interval of the form \{f, leftendp, rightendp\}  
	where f is a function and leftendp $<$ rightendp unless f is an  
	impulse function in which case leftendp must equal rightendp.  
	In a valid F-interval, leftendp and rightenp must be numbers.  
	See also IntervalQ. 
\item {\tt ValidOperatorQ} (in ``System.m'') \newline
	 ValidOperatorQ[system, signal1, signal2, ...] will return True  
	if every signal can be processed by the system.  
	For example, False would be returned if system was only a  
	discrete system and signal1 was a continuous signal. 
\item {\tt VariableQ} (in ``SupCode.m'') \newline
	 VariableQ[x] returns True if x is a symbol that  
	(1) does not have a numerical value associated with it and
	(2) does not have its Constant attribute enabled.  
	Pi fails the first test, so it is not considered a variable.  
	A variable can also have the form of C[n] where n is an integer  
	and C is a symbol whose Constant attribute is enabled. 
\item {\tt WithinROC} (in ``ROC.m'') \newline
	 WithinROC[rm1,rp1,rm2,rp2] returns True if the interval [rm1,rp1]  
	is a subset of the interval [rm2,rp2]. 
\item {\tt WriteSlot} (in ``Slot.m'') \newline
	 WriteSlot[object, slot, value] attempts to write over the slot  
	slot in object.  
	If the slot slot is read-only, then object is returned unaltered.  
	If the slot is not write protected, then the slot slot in object  
	is overwritten with value.  
	Note that object is an unevaluated symbol and that a slot value  
	cannot be a collection of values like (1, 2, 3). 
\item {\tt Z} (in ``SigProc.m'') \newline
	 Z[n, z] is the forward z-transform operator.  
	Applying TheFunction to the Z operator will invoke the z-transform  
	rule base ZTransform if loaded. 
\item {\tt ZForm} (in ``ZSupport.m'') \newline
	 ZForm[x] return True if the data packet x is tagged with  
	either List or Transform and contains three elements. 
\item {\tt ZPolynomial} (in ``SupCode.m'') \newline
	 ZPolynomial[m, n] is an mth order polynomial in the discrete  
	variable n defined by the product of (-n - k) for k = 0 ... m-1.  
	The z-transform of the product of this polynomial and some function  
	f[n] gives z\verb:^:m times the mth derivative of F(z). 
\item {\tt ZSolve} (in ``ZSolve.m'') \newline
	 ZSolve[ diffequ == drivingfun, y[n] ] solves the difference  
	equation diffequ = drivingfun, where diffequ is a linear constant  
	coefficient difference equation and drivingfun is the driving  
	function (a function of n).  
	Thus, diffequ has the form a0 y[n] + a1 y[n - 1] + ....  
	By using options, one can specify initial values; e.g.,  
	ZSolve[ y[n] + 3/2 y[n-1] + 1/2 y[n-2] == (1/4)\verb:^:n Step[n],  
	y[n], y[-1] -$>$ 4, y[-2] -$>$ 10 ].  
	A difference equations of N terms needs N-1 initial values.  
	All unspecified initial values are considered to be zero.  
	Right-sided and left-sided solutions are possible.  
	ZSolve can justify its answers. 
\item {\tt ZTransData} (in ``ROC.m'') \newline
	 ZTransData is a data tag for a valid z-transform object. 
\item {\tt ZTransform} (in ``ZTransform.m'') \newline
	 ZTransform[e,n] or ZTransform[e,n,z] gives the z-transform of  
	the expression e, which is a function of n, by returning an object  
	of three slots which is tagged by ZTransData:  
	$<$z-transform$>$, $<$rminus$>$, $<$rplus$>$, and $<$z-variables$>$.  
	The Region of Convergence (ROC) is $<$rminus$>$ $<$ $|$z$|$ $<$ $<$rplus$>$.  
	Note that the returned ROC is either the actual ROC or a subset  
	of the actual ROC.  
	In two dimensions, ZTransform[e, \{n1, n2\}, \{z1, z2\}], is the same as  
	ZTransform [ ZTransform [e, n1, z1], n2, z2 ].  
	This notation extends naturally to higher dimensions. 
\item {\tt ZTransformQ} (in ``ZSupport.m'') \newline
	 ZTransformQ[x] returns True if the datum x is of the form  
	ZTransData[X, rm, rp, z], where X is the z-transform, rm is the  
	Rminus component of the region of convergence, rp is the  
	Rplus component of the region of convergence, and z is  
	the variable(s) in the z-transform. 
\item {\tt ZUpsampledQ} (in ``ZSupport.m'') \newline
	 ZUpsampledQ[f, n] returns True if the sequence f, as a function  
	of n, has been upsampled.  
	See UpsampleFactor. 
\item {\tt ZVariables} (in ``ROC.m'') \newline
	 ZVariables is a data tag for the variables in a z-transform object.  
        When applied to an object x containing z-transform information,  
	ZVariables[x] returns the z-variables contained in the z-transform.  
	For example, if x is a z-transform object of the form  
	ZTransData[ zexpr, Rminus[r-], Rplus[r+], ZVariables[z] ], then  
	ZVariables would return z. 
\item {\tt ZeroQ} (in ``SupCode.m'') \newline
	 ZeroQ[x] returns True if x is 0 or 0.0 
\end{enumerate}
\end{document}

